From 39a817e7b4f09e9aaad296e2509a7b9db7bd80f5 Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Thu, 9 Jul 2026 20:36:08 +0300 Subject: [PATCH 1/7] gh-152905: Decode LC_TIME items in nl_langinfo() from glibc wide data (GH-152911) On glibc, locale.nl_langinfo() now decodes the LC_TIME text items from the wide (_NL_W*) locale data, independently of the LC_CTYPE encoding. Co-Authored-By: Claude Opus 4.8 (1M context) --- Doc/library/locale.rst | 4 + Lib/test/test__locale.py | 77 ++++++++++++++- ...-07-01-23-17-27.gh-issue-152905.wLnGqR.rst | 3 + Modules/_localemodule.c | 96 +++++++++++++------ 4 files changed, 152 insertions(+), 28 deletions(-) create mode 100644 Misc/NEWS.d/next/Library/2026-07-01-23-17-27.gh-issue-152905.wLnGqR.rst diff --git a/Doc/library/locale.rst b/Doc/library/locale.rst index e02cbe7d669f8b4..933ad039b6505f9 100644 --- a/Doc/library/locale.rst +++ b/Doc/library/locale.rst @@ -342,6 +342,10 @@ The :mod:`!locale` module defines the following exception and functions: .. versionchanged:: 3.14 The function now temporarily sets the ``LC_CTYPE`` locale in some cases. + .. versionchanged:: next + On glibc, the ``LC_TIME`` items (except ``ERA``) are now decoded + independently of the ``LC_CTYPE`` encoding. + .. function:: getdefaultlocale([envvars]) diff --git a/Lib/test/test__locale.py b/Lib/test/test__locale.py index 29a29ca0c650974..a0b0fd7eda994d4 100644 --- a/Lib/test/test__locale.py +++ b/Lib/test/test__locale.py @@ -1,3 +1,4 @@ +import _locale from _locale import (setlocale, LC_ALL, LC_CTYPE, LC_NUMERIC, LC_TIME, localeconv, Error) try: from _locale import (RADIXCHAR, THOUSEP, nl_langinfo) @@ -6,8 +7,9 @@ import locale import sys +import unicodedata import unittest -from platform import uname +from platform import uname, libc_ver from test import support @@ -271,6 +273,79 @@ def test_era_nl_langinfo(self): if not tested: self.skipTest('no suitable locales') + @unittest.skipUnless(nl_langinfo, "nl_langinfo is not available") + @unittest.skipUnless(libc_ver()[0] == 'glibc', + "wide nl_langinfo variants are glibc-specific") + def test_nl_langinfo_encoding_independent(self): + # gh-152905: The LC_TIME text items are decoded independently of the + # LC_CTYPE encoding (on glibc via the wide nl_langinfo variants), so + # the same locale in different encodings yields identical strings. + # ERA has no wide variant and is not tested. + self.addCleanup(setlocale, LC_TIME, setlocale(LC_TIME)) + + names = [f'MON_{i}' for i in range(1, 13)] + names += [f'ABMON_{i}' for i in range(1, 13)] + names += [f'DAY_{i}' for i in range(1, 8)] + names += [f'ABDAY_{i}' for i in range(1, 8)] + names += ['AM_STR', 'PM_STR', 'D_T_FMT', 'D_FMT', 'T_FMT'] + names += [name for name in ('T_FMT_AMPM', 'ERA_D_FMT', 'ERA_D_T_FMT', + 'ERA_T_FMT', 'ALT_DIGITS', '_DATE_FMT') + if hasattr(_locale, name)] + items = [(name, getattr(_locale, name)) for name in names] + + # Legacy (non-UTF-8) locales, compared against their UTF-8 variant. + legacy_locales = [ + 'en_US.ISO8859-1', + 'es_ES.ISO8859-1', + 'fr_FR.ISO8859-1', + 'de_DE.ISO8859-1', + 'pl_PL.ISO8859-2', + 'mt_MT.ISO8859-3', + 'ar_SA.ISO8859-6', + 'el_GR.ISO8859-7', + 'he_IL.ISO8859-8', + 'tr_TR.ISO8859-9', + 'lt_LT.ISO8859-13', + 'cy_GB.ISO8859-14', + 'et_EE.ISO8859-15', + 'uk_UA.KOI8-U', + 'bg_BG.CP1251', + 'ja_JP.EUC-JP', + 'ko_KR.EUC-KR', + 'zh_CN.GB2312', + 'zh_TW.BIG5', + 'th_TH.TIS-620', + ] + + # An 8-bit locale substitutes an equivalent for a space it cannot + # encode (e.g. es_ES has U+202F in UTF-8 but U+00A0 in ISO-8859-1), + # so fold spaces before comparing. + def fold_spaces(s): + return ''.join(' ' if unicodedata.category(c) == 'Zs' else c + for c in s) + + tested = False + for legacy_locale in legacy_locales: + locs = (legacy_locale.partition('.')[0] + '.UTF-8', legacy_locale) + values = [] + for loc in locs: + try: + setlocale(LC_TIME, loc) + except Error: + break + values.append({name: nl_langinfo(item) for name, item in items}) + if len(values) < 2: + continue + tested = True + + # The result must not depend on the locale encoding. + for name, item in items: + with self.subTest(locales=locs, name=name): + self.assertEqual(fold_spaces(values[0][name]), + fold_spaces(values[1][name])) + if not tested: + self.skipTest('no suitable locale pairs') + def test_float_parsing(self): # Bug #1391872: Test whether float parsing is okay on European # locales. diff --git a/Misc/NEWS.d/next/Library/2026-07-01-23-17-27.gh-issue-152905.wLnGqR.rst b/Misc/NEWS.d/next/Library/2026-07-01-23-17-27.gh-issue-152905.wLnGqR.rst new file mode 100644 index 000000000000000..99f20e65ad8e08f --- /dev/null +++ b/Misc/NEWS.d/next/Library/2026-07-01-23-17-27.gh-issue-152905.wLnGqR.rst @@ -0,0 +1,3 @@ +On glibc, :func:`locale.nl_langinfo` now decodes the ``LC_TIME`` items (such +as the month and day names) using the wide locale data, so the result no +longer depends on the ``LC_CTYPE`` encoding. diff --git a/Modules/_localemodule.c b/Modules/_localemodule.c index 8f7d662b00b21b5..0f71358a180dd29 100644 --- a/Modules/_localemodule.c +++ b/Modules/_localemodule.c @@ -561,11 +561,23 @@ _locale__getdefaultlocale_impl(PyObject *module) #endif #ifdef HAVE_LANGINFO_H -#define LANGINFO(X, Y) {#X, X, Y} +/* On glibc, LC_TIME text items also have a wide (_NL_W*) form, named + _NL_W, that nl_langinfo() returns as wchar_t*. LANGINFO_NW + marks the items that have no wide counterpart. */ +#ifdef __GLIBC__ +# define LANGINFO(X, Y) {#X, X, Y, _NL_W ## X} +# define LANGINFO_NW(X, Y) {#X, X, Y, 0} +#else +# define LANGINFO(X, Y) {#X, X, Y} +# define LANGINFO_NW(X, Y) {#X, X, Y} +#endif static struct langinfo_constant{ const char *name; int value; int category; +#ifdef __GLIBC__ + nl_item wide; /* wide _NL_W* counterpart, or 0 if none */ +#endif } langinfo_constants[] = { /* These constants should exist on any langinfo implementation */ @@ -613,8 +625,8 @@ static struct langinfo_constant{ #ifdef RADIXCHAR /* The following are not available with glibc 2.0 */ - LANGINFO(RADIXCHAR, LC_NUMERIC), - LANGINFO(THOUSEP, LC_NUMERIC), + LANGINFO_NW(RADIXCHAR, LC_NUMERIC), + LANGINFO_NW(THOUSEP, LC_NUMERIC), /* YESSTR and NOSTR are deprecated in glibc, since they are a special case of message translation, which should be rather done using gettext. So we don't expose it to Python in the @@ -622,7 +634,7 @@ static struct langinfo_constant{ LANGINFO(YESSTR, LC_MESSAGES), LANGINFO(NOSTR, LC_MESSAGES), */ - LANGINFO(CRNCYSTR, LC_MONETARY), + LANGINFO_NW(CRNCYSTR, LC_MONETARY), #endif LANGINFO(D_T_FMT, LC_TIME), @@ -636,13 +648,13 @@ static struct langinfo_constant{ a few of the others. Solution: ifdef-test them all. */ #ifdef CODESET - LANGINFO(CODESET, LC_CTYPE), + LANGINFO_NW(CODESET, LC_CTYPE), #endif #ifdef T_FMT_AMPM LANGINFO(T_FMT_AMPM, LC_TIME), #endif #ifdef ERA - LANGINFO(ERA, LC_TIME), + LANGINFO_NW(ERA, LC_TIME), #endif #ifdef ERA_D_FMT LANGINFO(ERA_D_FMT, LC_TIME), @@ -657,10 +669,10 @@ static struct langinfo_constant{ LANGINFO(ALT_DIGITS, LC_TIME), #endif #ifdef YESEXPR - LANGINFO(YESEXPR, LC_MESSAGES), + LANGINFO_NW(YESEXPR, LC_MESSAGES), #endif #ifdef NOEXPR - LANGINFO(NOEXPR, LC_MESSAGES), + LANGINFO_NW(NOEXPR, LC_MESSAGES), #endif #ifdef _DATE_FMT /* This is not available in all glibc versions that have CODESET. */ @@ -709,15 +721,14 @@ restore_locale(char *oldloc) } #ifdef __GLIBC__ -#if defined(ALT_DIGITS) || defined(ERA) static PyObject * -decode_strings(const char *result, size_t max_count) +decode_strings(const char *result) { /* Convert a sequence of NUL-separated C strings to a Python string * containing semicolon separated items. */ size_t i = 0; size_t count = 0; - for (; count < max_count && result[i]; count++) { + for (; result[i]; count++) { i += strlen(result + i) + 1; } char *buf = PyMem_Malloc(i); @@ -737,7 +748,35 @@ decode_strings(const char *result, size_t max_count) return pyresult; } #endif -#endif + +#ifdef __GLIBC__ +static PyObject * +decode_wide_strings(const wchar_t *result, size_t max_count) +{ + /* Wide-character counterpart of decode_strings(): convert a sequence of + * NUL-separated wchar_t strings to a str with semicolon-separated items. */ + size_t i = 0; + size_t count = 0; + for (; count < max_count && result[i]; count++) { + i += wcslen(result + i) + 1; + } + wchar_t *buf = PyMem_New(wchar_t, i); + if (buf == NULL) { + PyErr_NoMemory(); + return NULL; + } + memcpy(buf, result, i * sizeof(wchar_t)); + /* Replace all NULs with semicolons. */ + i = 0; + while (--count) { + i += wcslen(buf + i); + buf[i++] = L';'; + } + PyObject *pyresult = PyUnicode_FromWideChar(buf, -1); + PyMem_Free(buf); + return pyresult; +} +#endif /* __GLIBC__ */ /*[clinic input] _locale.nl_langinfo @@ -758,6 +797,22 @@ _locale_nl_langinfo_impl(PyObject *module, int item) crash PyUnicode_FromString. */ for (i = 0; langinfo_constants[i].name; i++) { if (langinfo_constants[i].value == item) { +#ifdef __GLIBC__ + /* Prefer the wide variant: it is decoded independently of the + LC_CTYPE encoding. */ + nl_item wide = langinfo_constants[i].wide; + if (wide) { + const wchar_t *wresult = (const wchar_t *)nl_langinfo(wide); + if (wresult == NULL) { + wresult = L""; + } + /* ALT_DIGITS is a sequence of NUL-separated strings. */ + if (item == ALT_DIGITS && *wresult) { + return decode_wide_strings(wresult, 100); + } + return PyUnicode_FromWideChar(wresult, -1); + } +#endif /* Check NULL as a workaround for GNU libc's returning NULL instead of an empty string for nl_langinfo(ERA). */ const char *result = nl_langinfo(item); @@ -766,13 +821,8 @@ _locale_nl_langinfo_impl(PyObject *module, int item) if (langinfo_constants[i].category != LC_CTYPE && *result && ( #ifdef __GLIBC__ - // gh-133740: Always change the locale for ALT_DIGITS and ERA -# ifdef ALT_DIGITS - item == ALT_DIGITS || -# endif -# ifdef ERA + // gh-133740: Always change the locale for ERA item == ERA || -# endif #endif !is_all_ascii(result)) && change_locale(langinfo_constants[i].category, &oldloc) < 0) @@ -784,18 +834,10 @@ _locale_nl_langinfo_impl(PyObject *module, int item) /* According to the POSIX specification the result must be * a sequence of semicolon-separated strings. * But in Glibc they are NUL-separated. */ -#ifdef ALT_DIGITS - if (item == ALT_DIGITS && *result) { - pyresult = decode_strings(result, 100); - } - else -#endif -#ifdef ERA if (item == ERA && *result) { - pyresult = decode_strings(result, SIZE_MAX); + pyresult = decode_strings(result); } else -#endif #endif { pyresult = PyUnicode_DecodeLocale(result, NULL); From 6ba3ad55bd922f164acf8f20b884730b718ee433 Mon Sep 17 00:00:00 2001 From: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com> Date: Thu, 9 Jul 2026 21:23:31 +0300 Subject: [PATCH 2/7] gh-146531: Broaden `wm_iconbitmap` skip on macOS 26 Intel (#153348) --- Lib/test/test_tkinter/test_misc.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Lib/test/test_tkinter/test_misc.py b/Lib/test/test_tkinter/test_misc.py index 5a25d3689df89ce..0ebaac22a2971dd 100644 --- a/Lib/test/test_tkinter/test_misc.py +++ b/Lib/test/test_tkinter/test_misc.py @@ -1057,13 +1057,10 @@ def test_wm_iconbitmap(self): and sys.platform == 'darwin' and platform.machine() == 'x86_64' and platform.mac_ver()[0].startswith('26.') - and ( - patchlevel[:3] <= (8, 6, 17) - or (9, 0) <= patchlevel[:3] <= (9, 0, 3) - ) ): # https://github.com/python/cpython/issues/146531 # Tk bug 4a2070f0d3a99aa412bc582d386d575ca2f37323 + # Not fixed as of Tk 8.6.18 and 9.0.4. self.skipTest('wm iconbitmap hangs on macOS 26 Intel') self.assertEqual(t.wm_iconbitmap(), '') From fac72f1ee91fb380640a4c4be6df07a8f02d3110 Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Thu, 9 Jul 2026 20:28:15 +0200 Subject: [PATCH 3/7] gh-152132: Fix Py_RunMain() to return an exit code (#153446) * Fix Py_RunMain() to return an exit code, rather than calling Py_Exit(), when running a script, a command, or the REPL. * _PyRun_SimpleFile() now logs errors to stderr, for example if setting __main__.__file__ fails. * Add tests on Py_RunMain() exitcode. * Rename functions: * _PyRun_SimpleStringFlagsWithName() => _PyRun_SimpleString() * _PyRun_SimpleFileObject() => _PyRun_SimpleFile() * _PyRun_AnyFileObject() => _PyRun_AnyFile() * _PyRun_InteractiveLoopObject() => _PyRun_InteractiveLoop() * Change _PyRun_SimpleString(), _PyRun_SimpleFile(), _PyRun_AnyFile() and _PyRun_InteractiveLoop() return type to PyObject*. * pymain_repl() now displays the error if PySys_Audit() or import _pyrepl failed. * PyRun_SimpleFileExFlags() and PyRun_AnyFileExFlags() now log PyUnicode_DecodeFSDefault() error. So these functions can no longer return -1 with an exception set. --- Include/internal/pycore_pylifecycle.h | 3 - Include/internal/pycore_pythonrun.h | 15 +- Lib/test/test_embed.py | 68 +++++- ...-07-09-17-33-29.gh-issue-152132.Ma8MJZ.rst | 3 + Modules/_testcapi/run.c | 27 --- Modules/main.c | 173 ++++++++------- Programs/_testembed.c | 161 +++++++++++--- Python/pythonrun.c | 199 +++++++++--------- 8 files changed, 398 insertions(+), 251 deletions(-) create mode 100644 Misc/NEWS.d/next/C_API/2026-07-09-17-33-29.gh-issue-152132.Ma8MJZ.rst diff --git a/Include/internal/pycore_pylifecycle.h b/Include/internal/pycore_pylifecycle.h index 12e1e78526db35a..ab627c28c1fa5ee 100644 --- a/Include/internal/pycore_pylifecycle.h +++ b/Include/internal/pycore_pylifecycle.h @@ -108,9 +108,6 @@ extern int _Py_LegacyLocaleDetected(int warn); // Export for 'readline' shared extension PyAPI_FUNC(char*) _Py_SetLocaleFromEnv(int category); -// Export for special main.c string compiling with source tracebacks -int _PyRun_SimpleStringFlagsWithName(const char *command, const char* name, PyCompilerFlags *flags); - /* interpreter config */ diff --git a/Include/internal/pycore_pythonrun.h b/Include/internal/pycore_pythonrun.h index 66dd7cd843b04fc..b2126f3f71bb46e 100644 --- a/Include/internal/pycore_pythonrun.h +++ b/Include/internal/pycore_pythonrun.h @@ -8,23 +8,18 @@ extern "C" { # error "this header requires Py_BUILD_CORE define" #endif -extern int _PyRun_SimpleFileObject( +extern PyObject* _PyRun_SimpleFile( FILE *fp, PyObject *filename, int closeit, PyCompilerFlags *flags); -extern int _PyRun_AnyFileObject( +extern PyObject* _PyRun_AnyFile( FILE *fp, PyObject *filename, int closeit, PyCompilerFlags *flags); -extern int _PyRun_InteractiveLoopObject( - FILE *fp, - PyObject *filename, - PyCompilerFlags *flags); - extern int _PyObject_SupportedAsScript(PyObject *); extern const char* _Py_SourceAsString( PyObject *cmd, @@ -39,6 +34,12 @@ extern PyObject * _Py_CompileStringObjectWithModule( PyCompilerFlags *flags, int optimize, PyObject *module); +// Export for special main.c string compiling with source tracebacks +extern PyObject* _PyRun_SimpleString( + const char *command, + PyObject* name, + PyCompilerFlags *flags); + /* Stack size, in "pointers". This must be large enough, so * no two calls to check recursion depth are more than this far diff --git a/Lib/test/test_embed.py b/Lib/test/test_embed.py index d0ac1d1c0cb1a15..40036609a190551 100644 --- a/Lib/test/test_embed.py +++ b/Lib/test/test_embed.py @@ -68,6 +68,9 @@ if not os.path.isfile(os.path.join(STDLIB_INSTALL, 'os.py')): STDLIB_INSTALL = None +CODE_EXITCODE_123 = 'raise SystemExit(123)' + + def debug_build(program): program = os.path.basename(program) name = os.path.splitext(program)[0] @@ -140,12 +143,16 @@ def run_embedded_interpreter(self, *args, env=None, env = env.copy() env['SYSTEMROOT'] = os.environ['SYSTEMROOT'] - p = subprocess.Popen(cmd, - stdout=subprocess.PIPE, - stderr=subprocess.PIPE, - universal_newlines=True, - env=env, - cwd=cwd) + kwargs = dict( + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + universal_newlines=True, + env=env, + cwd=cwd, + ) + if input is not None: + kwargs['stdin'] = subprocess.PIPE + p = subprocess.Popen(cmd, **kwargs) try: (out, err) = p.communicate(input=input, timeout=timeout) except: @@ -590,6 +597,55 @@ def _nogil_filtered_err(err: str, mod_name: str) -> str: ] return "\n".join(filtered_err_lines) + def check_program_exitcode(self, *args, check_stderr=True, **kwargs): + out, err = self.run_embedded_interpreter(*args, **kwargs) + self.assertEqual(out.rstrip(), 'ok! Py_RunMain() returned 123') + if check_stderr: + self.assertEqual(err, '') + + def test_init_run_main_code_exitcode(self): + code = CODE_EXITCODE_123 + self.check_program_exitcode("test_init_run_main_code_exitcode", code) + + def test_init_run_main_script_exitcode(self): + with tempfile.TemporaryDirectory() as tmpdir: + filename = os.path.join(tmpdir, 'script.py') + with open(filename, 'w') as fp: + fp.write(CODE_EXITCODE_123) + + self.check_program_exitcode("test_init_run_main_script_exitcode", + filename) + + def test_init_run_main_interactive_exitcode(self): + code = CODE_EXITCODE_123 + self.check_program_exitcode("test_init_run_main_interactive_exitcode", + input=code, + check_stderr=False) + + def test_init_run_main_startup_exitcode(self): + with tempfile.TemporaryDirectory() as tmpdir: + filename = os.path.join(tmpdir, 'startup.py') + with open(filename, 'x') as fp: + fp.write(CODE_EXITCODE_123) + + env = dict(os.environ) + env['PYTHONSTARTUP'] = filename + self.check_program_exitcode("test_init_run_main_interactive_exitcode", + env=env, + check_stderr=False) + + def test_init_run_main_module_exitcode(self): + with tempfile.TemporaryDirectory() as tmpdir: + modname = '_testembed_testmodule' + filename = os.path.join(tmpdir, modname + '.py') + with open(filename, 'x', encoding='utf8') as fp: + fp.write(CODE_EXITCODE_123) + + env = dict(os.environ) + env['PYTHONPATH'] = tmpdir + self.check_program_exitcode("test_init_run_main_module_exitcode", + modname, env=env) + def config_dev_mode(preconfig, config): preconfig['allocator'] = PYMEM_ALLOCATOR_DEBUG diff --git a/Misc/NEWS.d/next/C_API/2026-07-09-17-33-29.gh-issue-152132.Ma8MJZ.rst b/Misc/NEWS.d/next/C_API/2026-07-09-17-33-29.gh-issue-152132.Ma8MJZ.rst new file mode 100644 index 000000000000000..633c41e40bf2696 --- /dev/null +++ b/Misc/NEWS.d/next/C_API/2026-07-09-17-33-29.gh-issue-152132.Ma8MJZ.rst @@ -0,0 +1,3 @@ +Fix :c:func:`Py_RunMain` to return an exit code, rather than calling +:c:func:`Py_Exit`, when running a script, a command, or the REPL. Patch by +Victor Stinner. diff --git a/Modules/_testcapi/run.c b/Modules/_testcapi/run.c index 4a63c0f98a74d4c..7fc180e136559ba 100644 --- a/Modules/_testcapi/run.c +++ b/Modules/_testcapi/run.c @@ -129,9 +129,6 @@ run_simplefile(PyObject *mod, PyObject *args) assert(_Py_IsValidFD(fd)); fclose(fp); - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } @@ -203,9 +200,6 @@ run_simplefileex(PyObject *mod, PyObject *args) return NULL; } - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } @@ -243,9 +237,6 @@ run_simplefileexflags(PyObject *mod, PyObject *args) return NULL; } - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } @@ -272,9 +263,6 @@ run_anyfile(PyObject *mod, PyObject *args) assert(_Py_IsValidFD(fd)); fclose(fp); - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } @@ -310,9 +298,6 @@ run_anyfileflags(PyObject *mod, PyObject *args) assert(_Py_IsValidFD(fd)); fclose(fp); - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } @@ -342,9 +327,6 @@ run_anyfileex(PyObject *mod, PyObject *args) return NULL; } - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } @@ -382,9 +364,6 @@ run_anyfileexflags(PyObject *mod, PyObject *args) return NULL; } - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } @@ -664,9 +643,6 @@ run_simplestring(PyObject *mod, PyObject *args) } int res = PyRun_SimpleString(str); - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } @@ -689,9 +665,6 @@ run_simplestringflags(PyObject *mod, PyObject *args) } int res = PyRun_SimpleStringFlags(str, pflags); - if (res == -1 && PyErr_Occurred()) { - return NULL; - } assert(!PyErr_Occurred()); return PyLong_FromLong(res); } diff --git a/Modules/main.c b/Modules/main.c index 2f23513cc2403dc..a65247dc1e5c617 100644 --- a/Modules/main.c +++ b/Modules/main.c @@ -10,7 +10,7 @@ #include "pycore_pathconfig.h" // _PyPathConfig_ComputeSysPath0() #include "pycore_pylifecycle.h" // _Py_PreInitializeFromPyArgv() #include "pycore_pystate.h" // _PyInterpreterState_GET() -#include "pycore_pythonrun.h" // _PyRun_AnyFileObject() +#include "pycore_pythonrun.h" // _PyRun_AnyFile() #include "pycore_tuple.h" // _PyTuple_FromPair #include "pycore_unicodeobject.h" // _PyUnicode_Dedent() @@ -235,7 +235,6 @@ static int pymain_run_command(wchar_t *command) { PyObject *unicode, *bytes; - int ret; unicode = PyUnicode_FromWideChar(command, -1); if (unicode == NULL) { @@ -259,9 +258,18 @@ pymain_run_command(wchar_t *command) PyCompilerFlags cf = _PyCompilerFlags_INIT; cf.cf_flags |= PyCF_IGNORE_COOKIE; - ret = _PyRun_SimpleStringFlagsWithName(PyBytes_AsString(bytes), "", &cf); + PyObject *result = NULL; + PyObject *string_obj = PyUnicode_FromString(""); + if (string_obj != NULL) { + result = _PyRun_SimpleString(PyBytes_AsString(bytes), + string_obj, &cf); + Py_DECREF(string_obj); + } Py_DECREF(bytes); - return (ret != 0); + if (result == NULL) { + return pymain_exit_err_print(); + } + return 0; error: PySys_WriteStderr("Unable to decode the command from the command line:\n"); @@ -270,9 +278,9 @@ pymain_run_command(wchar_t *command) static int -pymain_start_pyrepl(int pythonstartup) +pymain_run_pyrepl(int pythonstartup) { - int res = 0; + int exitcode = 0; PyObject *console = NULL; PyObject *empty_tuple = NULL; PyObject *kwargs = NULL; @@ -282,37 +290,41 @@ pymain_start_pyrepl(int pythonstartup) PyObject *pyrepl = PyImport_ImportModule("_pyrepl.main"); if (pyrepl == NULL) { fprintf(stderr, "Could not import _pyrepl.main\n"); - res = pymain_exit_err_print(); - goto done; + goto error; } + console = PyObject_GetAttrString(pyrepl, "interactive_console"); if (console == NULL) { fprintf(stderr, "Could not access _pyrepl.main.interactive_console\n"); - res = pymain_exit_err_print(); - goto done; + goto error; } + empty_tuple = PyTuple_New(0); if (empty_tuple == NULL) { - res = pymain_exit_err_print(); - goto done; + goto error; } kwargs = PyDict_New(); if (kwargs == NULL) { - res = pymain_exit_err_print(); - goto done; + goto error; } + main_module = PyImport_AddModuleRef("__main__"); if (main_module == NULL) { - res = pymain_exit_err_print(); - goto done; + goto error; } - if (!PyDict_SetItemString(kwargs, "mainmodule", main_module) - && !PyDict_SetItemString(kwargs, "pythonstartup", pythonstartup ? Py_True : Py_False)) { - console_result = PyObject_Call(console, empty_tuple, kwargs); - if (console_result == NULL) { - res = pymain_exit_err_print(); - } + + PyObject *value = pythonstartup ? Py_True : Py_False; + if (PyDict_SetItemString(kwargs, "mainmodule", main_module) + || PyDict_SetItemString(kwargs, "pythonstartup", value)) + { + goto error; + } + + console_result = PyObject_Call(console, empty_tuple, kwargs); + if (console_result == NULL) { + goto error; } + done: Py_XDECREF(console_result); Py_XDECREF(kwargs); @@ -320,7 +332,11 @@ pymain_start_pyrepl(int pythonstartup) Py_XDECREF(console); Py_XDECREF(pyrepl); Py_XDECREF(main_module); - return res; + return exitcode; + +error: + exitcode = pymain_exit_err_print(); + goto done; } @@ -406,10 +422,14 @@ pymain_run_file_obj(PyObject *program_name, PyObject *filename, return pymain_exit_err_print(); } - /* PyRun_AnyFileExFlags(closeit=1) calls fclose(fp) before running code */ + /* _PyRun_AnyFile(closeit=1) calls fclose(fp) before running code */ PyCompilerFlags cf = _PyCompilerFlags_INIT; - int run = _PyRun_AnyFileObject(fp, filename, 1, &cf); - return (run != 0); + PyObject *result = _PyRun_AnyFile(fp, filename, 1, &cf); + if (result == NULL) { + return pymain_exit_err_print(); + } + Py_DECREF(result); + return 0; } static int @@ -417,28 +437,26 @@ pymain_run_file(const PyConfig *config) { PyObject *filename = PyUnicode_FromWideChar(config->run_filename, -1); if (filename == NULL) { - PyErr_Print(); - return -1; + return pymain_exit_err_print(); } PyObject *program_name = PyUnicode_FromWideChar(config->program_name, -1); if (program_name == NULL) { Py_DECREF(filename); - PyErr_Print(); - return -1; + return pymain_exit_err_print(); } - int res = pymain_run_file_obj(program_name, filename, - config->skip_source_first_line); + int exitcode = pymain_run_file_obj(program_name, filename, + config->skip_source_first_line); Py_DECREF(filename); Py_DECREF(program_name); - return res; + return exitcode; } static int pymain_run_startup(PyConfig *config, int *exitcode) { - int ret; + int ret = 0; if (!config->use_environment) { return 0; } @@ -478,10 +496,12 @@ pymain_run_startup(PyConfig *config, int *exitcode) } PyCompilerFlags cf = _PyCompilerFlags_INIT; - (void) _PyRun_SimpleFileObject(fp, startup, 0, &cf); - PyErr_Clear(); + PyObject *result = _PyRun_SimpleFile(fp, startup, 0, &cf); fclose(fp); - ret = 0; + if (result == NULL) { + goto error; + } + Py_DECREF(result); done: Py_XDECREF(startup); @@ -542,22 +562,8 @@ pymain_set_inspect(PyConfig *config, int inspect) static int -pymain_run_stdin(PyConfig *config) +_pymain_run_repl(PyConfig *config, int startup) { - if (stdin_is_interactive(config)) { - // do exit on SystemExit - pymain_set_inspect(config, 0); - - int exitcode; - if (pymain_run_startup(config, &exitcode)) { - return exitcode; - } - - if (pymain_run_interactive_hook(&exitcode)) { - return exitcode; - } - } - /* call pending calls like signal handlers (SIGINT) */ if (Py_MakePendingCalls() == -1) { return pymain_exit_err_print(); @@ -567,14 +573,13 @@ pymain_run_stdin(PyConfig *config) return pymain_exit_err_print(); } - int run; if (isatty(fileno(stdin)) && !_Py_GetEnv(config->use_environment, "PYTHON_BASIC_REPL")) { PyObject *pyrepl = PyImport_ImportModule("_pyrepl"); if (pyrepl != NULL) { - run = pymain_start_pyrepl(0); + int exitcode = pymain_run_pyrepl(startup); Py_DECREF(pyrepl); - return run; + return exitcode; } if (!PyErr_ExceptionMatches(PyExc_ModuleNotFoundError)) { fprintf(stderr, "Could not import _pyrepl.main\n"); @@ -584,8 +589,37 @@ pymain_run_stdin(PyConfig *config) } PyCompilerFlags cf = _PyCompilerFlags_INIT; - run = PyRun_AnyFileExFlags(stdin, "", 0, &cf); - return (run != 0); + PyObject *result = NULL; + PyObject *stdin_obj = PyUnicode_FromString(""); + if (stdin_obj != NULL) { + result = _PyRun_AnyFile(stdin, stdin_obj, 0, &cf); + Py_DECREF(stdin_obj); + } + if (result == NULL) { + return pymain_exit_err_print(); + } + Py_DECREF(result); + return 0; +} + +static int +pymain_run_stdin(PyConfig *config) +{ + if (stdin_is_interactive(config)) { + // do exit on SystemExit + pymain_set_inspect(config, 0); + + int exitcode; + if (pymain_run_startup(config, &exitcode)) { + return exitcode; + } + + if (pymain_run_interactive_hook(&exitcode)) { + return exitcode; + } + } + + return _pymain_run_repl(config, 0); } @@ -607,30 +641,7 @@ pymain_repl(PyConfig *config, int *exitcode) return; } - if (PySys_Audit("cpython.run_stdin", NULL) < 0) { - return; - } - - if (isatty(fileno(stdin)) - && !_Py_GetEnv(config->use_environment, "PYTHON_BASIC_REPL")) { - PyObject *pyrepl = PyImport_ImportModule("_pyrepl"); - if (pyrepl != NULL) { - int run = pymain_start_pyrepl(1); - *exitcode = (run != 0); - Py_DECREF(pyrepl); - return; - } - if (!PyErr_ExceptionMatches(PyExc_ModuleNotFoundError)) { - PyErr_Clear(); - fprintf(stderr, "Could not import _pyrepl.main\n"); - return; - } - PyErr_Clear(); - } - PyCompilerFlags cf = _PyCompilerFlags_INIT; - int run = PyRun_AnyFileExFlags(stdin, "", 0, &cf); - *exitcode = (run != 0); - return; + *exitcode = _pymain_run_repl(config, 1); } diff --git a/Programs/_testembed.c b/Programs/_testembed.c index 74d0fe37ddaeadb..418609abc5f6b82 100644 --- a/Programs/_testembed.c +++ b/Programs/_testembed.c @@ -64,6 +64,53 @@ static void error(const char *msg) } +static void error_fmt(const char *format, ...) +{ + va_list vargs; + va_start(vargs, format); + fprintf(stderr, "ERROR: "); + vfprintf(stderr, format, vargs); + fprintf(stderr, "\n"); + va_end(vargs); + fflush(stderr); +} + + +static wchar_t* py_getenv(const char *name) +{ + const char *env = getenv(name); + if (env == NULL) { + error_fmt("need %s env var", name); + return NULL; + } + + wchar_t *result = Py_DecodeLocale(env, NULL); + if (result == NULL) { + error("Py_DecodeLocale() failed"); + return NULL; + } + return result; +} + + +static wchar_t* get_cmdline_arg(const char *arg_name) +{ + if (main_argc < 3) { + const char *test = main_argv[1]; + fprintf(stderr, "usage: %s %s %s\n", PROGRAM, test, arg_name); + return NULL; + } + const char *arg = main_argv[2]; + + wchar_t *result = Py_DecodeLocale(arg, NULL); + if (result == NULL) { + error_fmt("failed to decode %s command line argument", arg_name); + return NULL; + } + return result; +} + + static void config_set_string(PyConfig *config, wchar_t **config_str, const wchar_t *str) { PyStatus status = PyConfig_SetString(config, config_str, str); @@ -1564,14 +1611,8 @@ static int test_init_sys_add(void) static int test_init_setpath(void) { - char *env = getenv("TESTPATH"); - if (!env) { - error("missing TESTPATH env var"); - return 1; - } - wchar_t *path = Py_DecodeLocale(env, NULL); + wchar_t *path = py_getenv("TESTPATH"); if (path == NULL) { - error("failed to decode TESTPATH"); return 1; } Py_SetPath(path); @@ -1597,14 +1638,8 @@ static int test_init_setpath_config(void) Py_ExitStatusException(status); } - char *env = getenv("TESTPATH"); - if (!env) { - error("missing TESTPATH env var"); - return 1; - } - wchar_t *path = Py_DecodeLocale(env, NULL); + wchar_t *path = py_getenv("TESTPATH"); if (path == NULL) { - error("failed to decode TESTPATH"); return 1; } Py_SetPath(path); @@ -1626,14 +1661,8 @@ static int test_init_setpath_config(void) static int test_init_setpythonhome(void) { - char *env = getenv("TESTHOME"); - if (!env) { - error("missing TESTHOME env var"); - return 1; - } - wchar_t *home = Py_DecodeLocale(env, NULL); + wchar_t *home = py_getenv("TESTHOME"); if (home == NULL) { - error("failed to decode TESTHOME"); return 1; } Py_SetPythonHome(home); @@ -1651,14 +1680,8 @@ static int test_init_is_python_build(void) { // gh-91985: in-tree builds fail to check for build directory landmarks // under the effect of 'home' or PYTHONHOME environment variable. - char *env = getenv("TESTHOME"); - if (!env) { - error("missing TESTHOME env var"); - return 1; - } - wchar_t *home = Py_DecodeLocale(env, NULL); + wchar_t *home = py_getenv("TESTHOME"); if (home == NULL) { - error("failed to decode TESTHOME"); return 1; } @@ -1672,7 +1695,7 @@ static int test_init_is_python_build(void) // Use an impossible value so we can detect whether it isn't updated // during initialization. config._is_python_build = INT_MAX; - env = getenv("NEGATIVE_ISPYTHONBUILD"); + char *env = getenv("NEGATIVE_ISPYTHONBUILD"); if (env && strcmp(env, "0") != 0) { config._is_python_build = INT_MIN; } @@ -1997,6 +2020,82 @@ static int test_init_run_main(void) } +static int test_init_run_main_exitcode(Py_ssize_t argc, wchar_t * const *argv) +{ + PyConfig config; + PyConfig_InitPythonConfig(&config); + + config.parse_argv = 1; + config_set_argv(&config, argc, argv); + config_set_string(&config, &config.program_name, L"./python3"); + + init_from_config_clear(&config); + + int exitcode = Py_RunMain(); + if (exitcode != 123) { + error_fmt("Py_RunMain() returned %i, expected 123", exitcode); + return 1; + } + + // If Py_RunMain() calls Py_Exit(), this message is not written to stdout + printf("ok! Py_RunMain() returned 123\n"); + + return 0; +} + + +static int test_init_run_main_script_exitcode(void) +{ + wchar_t *filename = get_cmdline_arg("FILENAME"); + if (filename == NULL) { + return 1; + } + + wchar_t* argv[] = {L"python3", filename}; + int res = test_init_run_main_exitcode(Py_ARRAY_LENGTH(argv), argv); + PyMem_RawFree(filename); + + return res; +} + + +static int test_init_run_main_module_exitcode(void) +{ + wchar_t *module = get_cmdline_arg("MODULE"); + if (module == NULL) { + return 1; + } + + wchar_t* argv[] = {L"python3", L"-m", module}; + int res = test_init_run_main_exitcode(Py_ARRAY_LENGTH(argv), argv); + PyMem_RawFree(module); + + return res; +} + + +static int test_init_run_main_interactive_exitcode(void) +{ + wchar_t* argv[] = {L"python3", L"-i"}; + return test_init_run_main_exitcode(Py_ARRAY_LENGTH(argv), argv); +} + + +static int test_init_run_main_code_exitcode(void) +{ + wchar_t *code = get_cmdline_arg("CODE"); + if (code == NULL) { + return 1; + } + + wchar_t* argv[] = {L"python3", L"-c", code}; + int res = test_init_run_main_exitcode(Py_ARRAY_LENGTH(argv), argv); + PyMem_RawFree(code); + + return res; +} + + static int test_init_main(void) { PyConfig config; @@ -2938,6 +3037,10 @@ static struct TestCase TestCases[] = { {"test_preinit_parse_argv", test_preinit_parse_argv}, {"test_preinit_dont_parse_argv", test_preinit_dont_parse_argv}, {"test_init_run_main", test_init_run_main}, + {"test_init_run_main_code_exitcode", test_init_run_main_code_exitcode}, + {"test_init_run_main_script_exitcode", test_init_run_main_script_exitcode}, + {"test_init_run_main_module_exitcode", test_init_run_main_module_exitcode}, + {"test_init_run_main_interactive_exitcode", test_init_run_main_interactive_exitcode}, {"test_init_main", test_init_main}, {"test_init_sys_add", test_init_sys_add}, {"test_init_setpath", test_init_setpath}, diff --git a/Python/pythonrun.c b/Python/pythonrun.c index 8c441e7ebd3c79f..e0a752720dfcc2d 100644 --- a/Python/pythonrun.c +++ b/Python/pythonrun.c @@ -22,7 +22,7 @@ #include "pycore_pyerrors.h" // _PyErr_GetRaisedException() #include "pycore_pylifecycle.h" // _Py_FdIsInteractive() #include "pycore_pystate.h" // _PyInterpreterState_GET() -#include "pycore_pythonrun.h" // export _PyRun_InteractiveLoopObject() +#include "pycore_pythonrun.h" // export _PyRun_AnyFile() #include "pycore_sysmodule.h" // _PySys_SetAttr() #include "pycore_traceback.h" // _PyTraceBack_Print() #include "pycore_unicodeobject.h" // _PyUnicode_Equal() @@ -41,50 +41,53 @@ # include "windows.h" #endif -/* Forward */ +/* Forward declarations */ static void flush_io(void); static PyObject *run_mod(mod_ty, PyObject *, PyObject *, PyObject *, PyCompilerFlags *, PyArena *, PyObject*, int); static PyObject *run_pyc_file(FILE *, PyObject *, PyObject *, PyCompilerFlags *); -static int PyRun_InteractiveOneObjectEx(FILE *, PyObject *, PyCompilerFlags *); -static PyObject* pyrun_file(FILE *fp, PyObject *filename, int start, - PyObject *globals, PyObject *locals, int closeit, - PyCompilerFlags *flags); static PyObject * -_PyRun_StringFlagsWithName(const char *str, PyObject* name, int start, - PyObject *globals, PyObject *locals, PyCompilerFlags *flags, - int generate_new_source); +_PyRun_String(const char *str, PyObject* name, int start, + PyObject *globals, PyObject *locals, PyCompilerFlags *flags, + int generate_new_source); +static PyObject* +_PyRun_InteractiveLoop(FILE *fp, PyObject *filename, PyCompilerFlags *flags); +static int +_PyRun_InteractiveOne(FILE *fp, PyObject *filename, PyCompilerFlags *flags); +static PyObject * +_PyRun_File(FILE *fp, PyObject *filename, int start, PyObject *globals, + PyObject *locals, int closeit, PyCompilerFlags *flags); -int -_PyRun_AnyFileObject(FILE *fp, PyObject *filename, int closeit, - PyCompilerFlags *flags) + +PyObject* +_PyRun_AnyFile(FILE *fp, PyObject *filename, int closeit, + PyCompilerFlags *flags) { int decref_filename = 0; if (filename == NULL) { filename = PyUnicode_FromString("???"); if (filename == NULL) { - PyErr_Print(); - return -1; + return NULL; } decref_filename = 1; } - int res; + PyObject *result; if (_Py_FdIsInteractive(fp, filename)) { - res = _PyRun_InteractiveLoopObject(fp, filename, flags); + result = _PyRun_InteractiveLoop(fp, filename, flags); if (closeit) { fclose(fp); } } else { - res = _PyRun_SimpleFileObject(fp, filename, closeit, flags); + result = _PyRun_SimpleFile(fp, filename, closeit, flags); } if (decref_filename) { Py_DECREF(filename); } - return res; + return result; } int @@ -99,14 +102,20 @@ PyRun_AnyFileExFlags(FILE *fp, const char *filename, int closeit, return -1; } } - int res = _PyRun_AnyFileObject(fp, filename_obj, closeit, flags); + + PyObject *result = _PyRun_AnyFile(fp, filename_obj, closeit, flags); Py_XDECREF(filename_obj); - return res; + if (result == NULL) { + PyErr_Print(); + return -1; + } + Py_DECREF(result); + return 0; } -int -_PyRun_InteractiveLoopObject(FILE *fp, PyObject *filename, PyCompilerFlags *flags) +static PyObject* +_PyRun_InteractiveLoop(FILE *fp, PyObject *filename, PyCompilerFlags *flags) { PyCompilerFlags local_flags = _PyCompilerFlags_INIT; if (flags == NULL) { @@ -115,8 +124,7 @@ _PyRun_InteractiveLoopObject(FILE *fp, PyObject *filename, PyCompilerFlags *flag PyObject *v; if (PySys_GetOptionalAttr(&_Py_ID(ps1), &v) < 0) { - PyErr_Print(); - return -1; + return NULL; } if (v == NULL) { v = PyUnicode_FromString(">>> "); @@ -129,8 +137,7 @@ _PyRun_InteractiveLoopObject(FILE *fp, PyObject *filename, PyCompilerFlags *flag } Py_XDECREF(v); if (PySys_GetOptionalAttr(&_Py_ID(ps2), &v) < 0) { - PyErr_Print(); - return -1; + return NULL; } if (v == NULL) { v = PyUnicode_FromString("... "); @@ -146,36 +153,41 @@ _PyRun_InteractiveLoopObject(FILE *fp, PyObject *filename, PyCompilerFlags *flag #ifdef Py_REF_DEBUG int show_ref_count = _Py_GetConfig()->show_ref_count; #endif - int err = 0; - int ret; int nomem_count = 0; + int ret; do { - ret = PyRun_InteractiveOneObjectEx(fp, filename, flags); + ret = _PyRun_InteractiveOne(fp, filename, flags); if (ret == -1 && PyErr_Occurred()) { /* Prevent an endless loop after multiple consecutive MemoryErrors * while still allowing an interactive command to fail with a * MemoryError. */ if (PyErr_ExceptionMatches(PyExc_MemoryError)) { if (++nomem_count > 16) { - PyErr_Clear(); - err = -1; - break; + return NULL; } } else { nomem_count = 0; } + + int inspect = _Py_GetConfig()->inspect; + if (!inspect && PyErr_ExceptionMatches(PyExc_SystemExit)) { + return NULL; + } + PyErr_Print(); - flush_io(); - } else { + } + else { nomem_count = 0; } + #ifdef Py_REF_DEBUG if (show_ref_count) { _PyDebug_PrintTotalRefs(); } #endif } while (ret != E_EOF); - return err; + + Py_RETURN_NONE; } @@ -188,10 +200,14 @@ PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flag return -1; } - int err = _PyRun_InteractiveLoopObject(fp, filename_obj, flags); + PyObject *result = _PyRun_InteractiveLoop(fp, filename_obj, flags); Py_DECREF(filename_obj); - return err; - + if (result == NULL) { + PyErr_Print(); + return -1; + } + Py_DECREF(result); + return 0; } @@ -287,8 +303,7 @@ pyrun_one_parse_ast(FILE *fp, PyObject *filename, /* A PyRun_InteractiveOneObject() auxiliary function that does not print the * error on failure. */ static int -PyRun_InteractiveOneObjectEx(FILE *fp, PyObject *filename, - PyCompilerFlags *flags) +_PyRun_InteractiveOne(FILE *fp, PyObject *filename, PyCompilerFlags *flags) { if (!PyUnicode_Check(filename)) { PyErr_Format(PyExc_TypeError, "expect str for filename, got %T", @@ -362,9 +377,7 @@ PyRun_InteractiveOneObjectEx(FILE *fp, PyObject *filename, int PyRun_InteractiveOneObject(FILE *fp, PyObject *filename, PyCompilerFlags *flags) { - int res; - - res = PyRun_InteractiveOneObjectEx(fp, filename, flags); + int res = _PyRun_InteractiveOne(fp, filename, flags); if (res == -1) { PyErr_Print(); flush_io(); @@ -464,24 +477,26 @@ set_main_loader(PyObject *d, PyObject *filename, const char *loader_name) } -int -_PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit, - PyCompilerFlags *flags) +PyObject* +_PyRun_SimpleFile(FILE *fp, PyObject *filename, int closeit, + PyCompilerFlags *flags) { - int ret = -1; + PyObject *res = NULL; + int set_file_name = 0; PyObject *main_module = PyImport_AddModuleRef("__main__"); - if (main_module == NULL) - return -1; + if (main_module == NULL) { + goto done; + } PyObject *dict = PyModule_GetDict(main_module); // borrowed ref - int set_file_name = 0; int has_file = PyDict_ContainsString(dict, "__file__"); if (has_file < 0) { goto done; } if (!has_file) { if (PyDict_SetItemString(dict, "__file__", filename) < 0) { + fprintf(stderr, "python: failed to set __main__.__file__\n"); goto done; } set_file_name = 1; @@ -492,7 +507,6 @@ _PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit, goto done; } - PyObject *v; if (pyc) { FILE *pyc_fp; /* Try to run a pyc file. First, re-open in binary */ @@ -508,39 +522,31 @@ _PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit, if (set_main_loader(dict, filename, "SourcelessFileLoader") < 0) { fprintf(stderr, "python: failed to set __main__.__loader__\n"); - ret = -1; fclose(pyc_fp); goto done; } - v = run_pyc_file(pyc_fp, dict, dict, flags); + res = run_pyc_file(pyc_fp, dict, dict, flags); } else { /* When running from stdin, leave __main__.__loader__ alone */ if ((!PyUnicode_Check(filename) || !PyUnicode_EqualToUTF8(filename, "")) && set_main_loader(dict, filename, "SourceFileLoader") < 0) { fprintf(stderr, "python: failed to set __main__.__loader__\n"); - ret = -1; goto done; } - v = pyrun_file(fp, filename, Py_file_input, dict, dict, - closeit, flags); + res = _PyRun_File(fp, filename, Py_file_input, dict, dict, + closeit, flags); } flush_io(); - if (v == NULL) { - Py_CLEAR(main_module); - PyErr_Print(); - goto done; - } - Py_DECREF(v); - ret = 0; done: if (set_file_name) { if (PyDict_PopString(dict, "__file__", NULL) < 0) { - PyErr_Print(); + fprintf(stderr, "python: failed to delete __main__.__file__\n"); + Py_CLEAR(res); } } Py_XDECREF(main_module); - return ret; + return res; } @@ -550,51 +556,47 @@ PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit, { PyObject *filename_obj = PyUnicode_DecodeFSDefault(filename); if (filename_obj == NULL) { + PyErr_Print(); return -1; } - int res = _PyRun_SimpleFileObject(fp, filename_obj, closeit, flags); + PyObject *result = _PyRun_SimpleFile(fp, filename_obj, closeit, flags); Py_DECREF(filename_obj); - return res; + if (result == NULL) { + PyErr_Print(); + return -1; + } + return 0; } -int -_PyRun_SimpleStringFlagsWithName(const char *command, const char* name, PyCompilerFlags *flags) { +PyObject* +_PyRun_SimpleString(const char *command, PyObject* name, + PyCompilerFlags *flags) +{ PyObject *main_module = PyImport_AddModuleRef("__main__"); if (main_module == NULL) { - return -1; + return NULL; } PyObject *dict = PyModule_GetDict(main_module); // borrowed ref - PyObject *res = NULL; - if (name == NULL) { - res = PyRun_StringFlags(command, Py_file_input, dict, dict, flags); - } else { - PyObject* the_name = PyUnicode_FromString(name); - if (!the_name) { - PyErr_Print(); - Py_DECREF(main_module); - return -1; - } - res = _PyRun_StringFlagsWithName(command, the_name, Py_file_input, dict, dict, flags, 0); - Py_DECREF(the_name); - } + PyObject *res = _PyRun_String(command, name, Py_file_input, + dict, dict, flags, 0); Py_DECREF(main_module); + return res; +} + +int +PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags) +{ + PyObject *res = _PyRun_SimpleString(command, NULL, flags); if (res == NULL) { PyErr_Print(); return -1; } - Py_DECREF(res); return 0; } -int -PyRun_SimpleStringFlags(const char *command, PyCompilerFlags *flags) -{ - return _PyRun_SimpleStringFlagsWithName(command, NULL, flags); -} - static int parse_exit_code(PyObject *code, int *exitcode_p) { @@ -1231,9 +1233,9 @@ void PyErr_DisplayException(PyObject *exc) } static PyObject * -_PyRun_StringFlagsWithName(const char *str, PyObject* name, int start, - PyObject *globals, PyObject *locals, PyCompilerFlags *flags, - int generate_new_source) +_PyRun_String(const char *str, PyObject* name, int start, + PyObject *globals, PyObject *locals, PyCompilerFlags *flags, + int generate_new_source) { PyObject *ret = NULL; mod_ty mod; @@ -1277,12 +1279,12 @@ PyObject * PyRun_StringFlags(const char *str, int start, PyObject *globals, PyObject *locals, PyCompilerFlags *flags) { - return _PyRun_StringFlagsWithName(str, NULL, start, globals, locals, flags, 0); + return _PyRun_String(str, NULL, start, globals, locals, flags, 0); } static PyObject * -pyrun_file(FILE *fp, PyObject *filename, int start, PyObject *globals, - PyObject *locals, int closeit, PyCompilerFlags *flags) +_PyRun_File(FILE *fp, PyObject *filename, int start, PyObject *globals, + PyObject *locals, int closeit, PyCompilerFlags *flags) { PyArena *arena = _PyArena_New(); if (arena == NULL) { @@ -1316,11 +1318,12 @@ PyRun_FileExFlags(FILE *fp, const char *filename, int start, PyObject *globals, { PyObject *filename_obj = PyUnicode_DecodeFSDefault(filename); if (filename_obj == NULL) { + PyErr_Print(); return NULL; } - PyObject *res = pyrun_file(fp, filename_obj, start, globals, - locals, closeit, flags); + PyObject *res = _PyRun_File(fp, filename_obj, start, globals, + locals, closeit, flags); Py_DECREF(filename_obj); return res; From b9e8979dcd563ee913c66802c8544aa050fda2d5 Mon Sep 17 00:00:00 2001 From: Xiaowei Lu Date: Fri, 10 Jul 2026 03:17:40 +0800 Subject: [PATCH 4/7] gh-152769: Enable perf trampoline on musl (Alpine Linux) (#152774) --- .../Build/2026-07-01-17-53-00.gh-issue-152769.Kp7mQ2.rst | 4 ++++ configure | 6 ++++++ configure.ac | 4 ++++ 3 files changed, 14 insertions(+) create mode 100644 Misc/NEWS.d/next/Build/2026-07-01-17-53-00.gh-issue-152769.Kp7mQ2.rst diff --git a/Misc/NEWS.d/next/Build/2026-07-01-17-53-00.gh-issue-152769.Kp7mQ2.rst b/Misc/NEWS.d/next/Build/2026-07-01-17-53-00.gh-issue-152769.Kp7mQ2.rst new file mode 100644 index 000000000000000..04a6ef4f5e0a7f8 --- /dev/null +++ b/Misc/NEWS.d/next/Build/2026-07-01-17-53-00.gh-issue-152769.Kp7mQ2.rst @@ -0,0 +1,4 @@ +Enable the :ref:`perf profiler ` trampoline on Alpine Linux with the +musl C library on ``x86_64`` and ``aarch64``. The +trampoline is architecture-specific and does not depend on the C library, so +the same assembly trampoline used for glibc is reused for musl. diff --git a/configure b/configure index 11ef14c46eeeaef..17b7ef765cc7fdf 100755 --- a/configure +++ b/configure @@ -14440,9 +14440,15 @@ case $PLATFORM_TRIPLET in #( x86_64-linux-gnu) : perf_trampoline=yes PERF_TRAMPOLINE_OBJ=Python/asm_trampoline_x86_64.o ;; #( + x86_64-linux-musl) : + perf_trampoline=yes + PERF_TRAMPOLINE_OBJ=Python/asm_trampoline_x86_64.o ;; #( aarch64-linux-gnu) : perf_trampoline=yes PERF_TRAMPOLINE_OBJ=Python/asm_trampoline_aarch64.o ;; #( + aarch64-linux-musl) : + perf_trampoline=yes + PERF_TRAMPOLINE_OBJ=Python/asm_trampoline_aarch64.o ;; #( darwin) : case $MACOSX_DEPLOYMENT_TARGET in #( 10.[0-9]|10.1[0-1]) : diff --git a/configure.ac b/configure.ac index 568286a9e468a36..ab64ac8769b5515 100644 --- a/configure.ac +++ b/configure.ac @@ -3874,8 +3874,12 @@ PERF_TRAMPOLINE_OBJ="" AS_CASE([$PLATFORM_TRIPLET], [x86_64-linux-gnu], [perf_trampoline=yes PERF_TRAMPOLINE_OBJ=Python/asm_trampoline_x86_64.o], + [x86_64-linux-musl], [perf_trampoline=yes + PERF_TRAMPOLINE_OBJ=Python/asm_trampoline_x86_64.o], [aarch64-linux-gnu], [perf_trampoline=yes PERF_TRAMPOLINE_OBJ=Python/asm_trampoline_aarch64.o], + [aarch64-linux-musl], [perf_trampoline=yes + PERF_TRAMPOLINE_OBJ=Python/asm_trampoline_aarch64.o], [darwin], [AS_CASE([$MACOSX_DEPLOYMENT_TARGET], [[10.[0-9]|10.1[0-1]]], [perf_trampoline=no], [perf_trampoline=yes From 311444998140240c164092640897013500b05963 Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Thu, 9 Jul 2026 21:27:40 +0200 Subject: [PATCH 5/7] gh-121608: Fix test_samply_profiler: only check samply once (#153424) Only run samply_command_works() once. Remove also dead code. --- Lib/test/test_samply_profiler.py | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/Lib/test/test_samply_profiler.py b/Lib/test/test_samply_profiler.py index f9ab9207c3c23d8..6c3be8f38ed0c00 100644 --- a/Lib/test/test_samply_profiler.py +++ b/Lib/test/test_samply_profiler.py @@ -31,12 +31,7 @@ def supports_trampoline_profiling(): raise unittest.SkipTest("perf trampoline profiling not supported") -def samply_command_works(): - try: - cmd = ["samply", "--help"] - except (subprocess.SubprocessError, OSError): - return False - +def _samply_command_works(): # Check that we can run a simple samply run with temp_dir() as script_dir: try: @@ -90,8 +85,10 @@ def run_samply(cwd, *args, **env_vars): with gzip.open(output_file, mode="rt", encoding="utf-8") as f: return f.read() +SAMPLY_COMMAND_WORKS = _samply_command_works() + -@unittest.skipUnless(samply_command_works(), "samply command doesn't work") +@unittest.skipUnless(SAMPLY_COMMAND_WORKS, "samply command doesn't work") class TestSamplyProfilerMixin: def run_samply(self, script_dir, perf_mode, script): raise NotImplementedError() @@ -145,7 +142,7 @@ def baz(n): self.assertNotIn(f"py::baz:{script}", output) -@unittest.skipUnless(samply_command_works(), "samply command doesn't work") +@unittest.skipUnless(SAMPLY_COMMAND_WORKS, "samply command doesn't work") class TestSamplyProfiler(unittest.TestCase, TestSamplyProfilerMixin): def run_samply(self, script_dir, script, activate_trampoline=True): if activate_trampoline: @@ -240,7 +237,7 @@ def compile_trampolines_for_all_functions(): self.assertIn(line, child_perf_file_contents) -@unittest.skipUnless(samply_command_works(), "samply command doesn't work") +@unittest.skipUnless(SAMPLY_COMMAND_WORKS, "samply command doesn't work") class TestSamplyProfilerWithJitDump(unittest.TestCase, TestSamplyProfilerMixin): # Regression test for gh-150723: exercises the binary jitdump backend # (-Xperf_jit) end to end through samply, unlike TestSamplyProfiler which From a159c6851f47549d2bc0cd37a0f555951bb11d7b Mon Sep 17 00:00:00 2001 From: stratakis Date: Thu, 9 Jul 2026 22:43:54 +0200 Subject: [PATCH 6/7] gh-98894: Quote test_dtrace tracer subcommands (#152901) Use shlex.join() when building tracer -c command strings for avoiding issues with spaces. --- Lib/test/test_dtrace.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/Lib/test/test_dtrace.py b/Lib/test/test_dtrace.py index e1662a70b26d3e3..30731b8f90ac14d 100644 --- a/Lib/test/test_dtrace.py +++ b/Lib/test/test_dtrace.py @@ -1,6 +1,7 @@ import dis import os.path import re +import shlex import signal import subprocess import sys @@ -92,7 +93,7 @@ def run_readelf(cmd): if proc.returncode: raise AssertionError( - f"Command {' '.join(cmd)!r} failed " + f"Command {shlex.join(cmd)!r} failed " f"with exit code {proc.returncode}: " f"stdout={stdout!r} stderr={stderr!r}" ) @@ -139,7 +140,7 @@ def trace(self, script_file, subcommand=None, *, timeout=None, raise if check_returncode and proc.returncode: raise AssertionError( - f"Command {' '.join(command)!r} failed " + f"Command {shlex.join(command)!r} failed " f"with exit code {proc.returncode}: output={stdout!r}" ) return stdout @@ -148,7 +149,7 @@ def trace_python(self, script_file, python_file, optimize_python=None): python_flags = [] if optimize_python: python_flags.extend(["-O"] * optimize_python) - subcommand = " ".join([sys.executable] + python_flags + [python_file]) + subcommand = shlex.join([sys.executable] + python_flags + [python_file]) return self.trace(script_file, subcommand, timeout=60, check_returncode=True) @@ -276,7 +277,7 @@ def run_case(self, name, optimize_python=None): try: proc = create_process_group( - ["bpftrace", "-e", program, "-c", " ".join(subcommand)], + ["bpftrace", "-e", program, "-c", shlex.join(subcommand)], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, @@ -314,7 +315,8 @@ def assert_usable(self): program = f'usdt:{sys.executable}:python:function__entry {{ printf("probe: success\\n"); exit(); }}' try: proc = create_process_group( - ["bpftrace", "-e", program, "-c", f"{sys.executable} -c pass"], + ["bpftrace", "-e", program, "-c", + shlex.join([sys.executable, "-c", "pass"])], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, From 87e5aac5ec85939cbd7623c0d7b4acc3cffd14ef Mon Sep 17 00:00:00 2001 From: Neil Schemenauer Date: Thu, 9 Jul 2026 15:08:36 -0700 Subject: [PATCH 7/7] Use enums for pycore_uop_ids.h. (gh-153351) This generally reduces the sizes of diffs when uops are added or removed. It also helps avoid merge conflicts. --- Include/internal/pycore_uop_ids.h | 2700 +++++++++++---------- Tools/cases_generator/uop_id_generator.py | 62 +- 2 files changed, 1402 insertions(+), 1360 deletions(-) diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index c30813f6d800f34..97f934727a85a36 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -9,44 +9,363 @@ extern "C" { #endif -#define _EXIT_TRACE 300 -#define _SET_IP 301 -#define _ALLOCATE_OBJECT 302 -#define _BINARY_OP 303 -#define _BINARY_OP_ADD_FLOAT 304 -#define _BINARY_OP_ADD_FLOAT_INPLACE 305 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT 306 -#define _BINARY_OP_ADD_INT 307 -#define _BINARY_OP_ADD_INT_INPLACE 308 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT 309 -#define _BINARY_OP_ADD_UNICODE 310 -#define _BINARY_OP_EXTEND 311 -#define _BINARY_OP_INPLACE_ADD_UNICODE 312 -#define _BINARY_OP_MULTIPLY_FLOAT 313 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE 314 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT 315 -#define _BINARY_OP_MULTIPLY_INT 316 -#define _BINARY_OP_MULTIPLY_INT_INPLACE 317 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT 318 -#define _BINARY_OP_SUBSCR_CHECK_FUNC 319 -#define _BINARY_OP_SUBSCR_DICT 320 -#define _BINARY_OP_SUBSCR_DICT_KNOWN_HASH 321 -#define _BINARY_OP_SUBSCR_INIT_CALL 322 -#define _BINARY_OP_SUBSCR_LIST_INT 323 -#define _BINARY_OP_SUBSCR_LIST_SLICE 324 -#define _BINARY_OP_SUBSCR_STR_INT 325 -#define _BINARY_OP_SUBSCR_TUPLE_INT 326 -#define _BINARY_OP_SUBSCR_USTR_INT 327 -#define _BINARY_OP_SUBTRACT_FLOAT 328 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE 329 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT 330 -#define _BINARY_OP_SUBTRACT_INT 331 -#define _BINARY_OP_SUBTRACT_INT_INPLACE 332 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT 333 -#define _BINARY_OP_TRUEDIV_FLOAT 334 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE 335 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT 336 -#define _BINARY_SLICE 337 +enum { + _EXIT_TRACE = 300, + _SET_IP, + _ALLOCATE_OBJECT, + _BINARY_OP, + _BINARY_OP_ADD_FLOAT, + _BINARY_OP_ADD_FLOAT_INPLACE, + _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT, + _BINARY_OP_ADD_INT, + _BINARY_OP_ADD_INT_INPLACE, + _BINARY_OP_ADD_INT_INPLACE_RIGHT, + _BINARY_OP_ADD_UNICODE, + _BINARY_OP_EXTEND, + _BINARY_OP_INPLACE_ADD_UNICODE, + _BINARY_OP_MULTIPLY_FLOAT, + _BINARY_OP_MULTIPLY_FLOAT_INPLACE, + _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT, + _BINARY_OP_MULTIPLY_INT, + _BINARY_OP_MULTIPLY_INT_INPLACE, + _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT, + _BINARY_OP_SUBSCR_CHECK_FUNC, + _BINARY_OP_SUBSCR_DICT, + _BINARY_OP_SUBSCR_DICT_KNOWN_HASH, + _BINARY_OP_SUBSCR_INIT_CALL, + _BINARY_OP_SUBSCR_LIST_INT, + _BINARY_OP_SUBSCR_LIST_SLICE, + _BINARY_OP_SUBSCR_STR_INT, + _BINARY_OP_SUBSCR_TUPLE_INT, + _BINARY_OP_SUBSCR_USTR_INT, + _BINARY_OP_SUBTRACT_FLOAT, + _BINARY_OP_SUBTRACT_FLOAT_INPLACE, + _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT, + _BINARY_OP_SUBTRACT_INT, + _BINARY_OP_SUBTRACT_INT_INPLACE, + _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT, + _BINARY_OP_TRUEDIV_FLOAT, + _BINARY_OP_TRUEDIV_FLOAT_INPLACE, + _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT, + _BINARY_SLICE, + _CALL_BUILTIN_CLASS, + _CALL_BUILTIN_FAST, + _CALL_BUILTIN_FAST_WITH_KEYWORDS, + _CALL_BUILTIN_O, + _CALL_FUNCTION_EX_NON_PY_GENERAL, + _CALL_INTRINSIC_1, + _CALL_INTRINSIC_2, + _CALL_ISINSTANCE, + _CALL_KW_NON_PY, + _CALL_LEN, + _CALL_LIST_APPEND, + _CALL_METHOD_DESCRIPTOR_FAST, + _CALL_METHOD_DESCRIPTOR_FAST_INLINE, + _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, + _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE, + _CALL_METHOD_DESCRIPTOR_NOARGS, + _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE, + _CALL_METHOD_DESCRIPTOR_O, + _CALL_METHOD_DESCRIPTOR_O_INLINE, + _CALL_NON_PY_GENERAL, + _CALL_STR_1, + _CALL_TUPLE_1, + _CALL_TYPE_1, + _CHECK_ATTR_CLASS, + _CHECK_ATTR_METHOD_LAZY_DICT, + _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, + _CHECK_FUNCTION_EXACT_ARGS, + _CHECK_FUNCTION_VERSION, + _CHECK_FUNCTION_VERSION_INLINE, + _CHECK_FUNCTION_VERSION_KW, + _CHECK_IS_NOT_PY_CALLABLE, + _CHECK_IS_NOT_PY_CALLABLE_EX, + _CHECK_IS_NOT_PY_CALLABLE_KW, + _CHECK_IS_PY_CALLABLE_EX, + _CHECK_MANAGED_OBJECT_HAS_VALUES, + _CHECK_METHOD_VERSION, + _CHECK_METHOD_VERSION_KW, + _CHECK_OBJECT, + _CHECK_PEP_523, + _CHECK_PERIODIC, + _CHECK_PERIODIC_AT_END, + _CHECK_PERIODIC_IF_NOT_YIELD_FROM, + _CHECK_RECURSION_LIMIT, + _CHECK_RECURSION_REMAINING, + _CHECK_STACK_SPACE, + _CHECK_STACK_SPACE_OPERAND, + _CHECK_VALIDITY, + _COLD_DYNAMIC_EXIT, + _COLD_EXIT, + _COMPARE_OP, + _COMPARE_OP_FLOAT, + _COMPARE_OP_INT, + _COMPARE_OP_STR, + _CONTAINS_OP, + _CONTAINS_OP_DICT, + _CONTAINS_OP_SET, + _COPY, + _COPY_1, + _COPY_2, + _COPY_3, + _CREATE_INIT_FRAME, + _DEOPT, + _DICT_MERGE, + _DICT_UPDATE, + _DO_CALL, + _DO_CALL_FUNCTION_EX, + _DO_CALL_KW, + _DYNAMIC_EXIT, + _ERROR_POP_N, + _EXPAND_METHOD, + _EXPAND_METHOD_KW, + _FATAL_ERROR, + _FOR_ITER, + _FOR_ITER_GEN_FRAME, + _FOR_ITER_TIER_TWO, + _FOR_ITER_VIRTUAL, + _FOR_ITER_VIRTUAL_TIER_TWO, + _GET_ITER, + _GET_ITER_TRAD, + _GUARD_3OS_ASYNC_GEN_ASEND, + _GUARD_BINARY_OP_EXTEND, + _GUARD_BINARY_OP_EXTEND_LHS, + _GUARD_BINARY_OP_EXTEND_RHS, + _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS, + _GUARD_BIT_IS_SET_POP, + _GUARD_BIT_IS_SET_POP_4, + _GUARD_BIT_IS_SET_POP_5, + _GUARD_BIT_IS_SET_POP_6, + _GUARD_BIT_IS_SET_POP_7, + _GUARD_BIT_IS_UNSET_POP, + _GUARD_BIT_IS_UNSET_POP_4, + _GUARD_BIT_IS_UNSET_POP_5, + _GUARD_BIT_IS_UNSET_POP_6, + _GUARD_BIT_IS_UNSET_POP_7, + _GUARD_CALLABLE_BUILTIN_CLASS, + _GUARD_CALLABLE_BUILTIN_FAST, + _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS, + _GUARD_CALLABLE_BUILTIN_O, + _GUARD_CALLABLE_ISINSTANCE, + _GUARD_CALLABLE_LEN, + _GUARD_CALLABLE_LIST_APPEND, + _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST, + _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, + _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS, + _GUARD_CALLABLE_METHOD_DESCRIPTOR_O, + _GUARD_CALLABLE_STR_1, + _GUARD_CALLABLE_TUPLE_1, + _GUARD_CALLABLE_TYPE_1, + _GUARD_CODE_VERSION_RETURN_GENERATOR, + _GUARD_CODE_VERSION_RETURN_VALUE, + _GUARD_CODE_VERSION_YIELD_VALUE, + _GUARD_CODE_VERSION__PUSH_FRAME, + _GUARD_DORV_NO_DICT, + _GUARD_GLOBALS_VERSION, + _GUARD_IP_RETURN_GENERATOR, + _GUARD_IP_RETURN_VALUE, + _GUARD_IP_YIELD_VALUE, + _GUARD_IP__PUSH_FRAME, + _GUARD_IS_FALSE_POP, + _GUARD_IS_NONE_POP, + _GUARD_IS_NOT_NONE_POP, + _GUARD_IS_TRUE_POP, + _GUARD_ITERATOR, + _GUARD_ITER_VIRTUAL, + _GUARD_LOAD_SUPER_ATTR_METHOD, + _GUARD_NOS_COMPACT_ASCII, + _GUARD_NOS_DICT_STORE_SUBSCRIPT, + _GUARD_NOS_DICT_SUBSCRIPT, + _GUARD_NOS_FLOAT, + _GUARD_NOS_INT, + _GUARD_NOS_ITER_VIRTUAL, + _GUARD_NOS_LIST, + _GUARD_NOS_NOT_NULL, + _GUARD_NOS_NULL, + _GUARD_NOS_OVERFLOWED, + _GUARD_NOS_TUPLE, + _GUARD_NOS_TYPE_VERSION, + _GUARD_NOS_UNICODE, + _GUARD_NOT_EXHAUSTED_LIST, + _GUARD_NOT_EXHAUSTED_RANGE, + _GUARD_NOT_EXHAUSTED_TUPLE, + _GUARD_THIRD_NULL, + _GUARD_TOS_ANY_DICT, + _GUARD_TOS_ANY_SET, + _GUARD_TOS_DICT, + _GUARD_TOS_FLOAT, + _GUARD_TOS_FROZENDICT, + _GUARD_TOS_FROZENSET, + _GUARD_TOS_INT, + _GUARD_TOS_IS_NONE, + _GUARD_TOS_LIST, + _GUARD_TOS_NOT_NULL, + _GUARD_TOS_OVERFLOWED, + _GUARD_TOS_SET, + _GUARD_TOS_SLICE, + _GUARD_TOS_TUPLE, + _GUARD_TOS_UNICODE, + _GUARD_TYPE, + _GUARD_TYPE_ITER, + _GUARD_TYPE_VERSION, + _GUARD_TYPE_VERSION_LOCKED, + _HANDLE_PENDING_AND_DEOPT, + _INIT_CALL_BOUND_METHOD_EXACT_ARGS, + _INIT_CALL_PY_EXACT_ARGS, + _INIT_CALL_PY_EXACT_ARGS_0, + _INIT_CALL_PY_EXACT_ARGS_1, + _INIT_CALL_PY_EXACT_ARGS_2, + _INIT_CALL_PY_EXACT_ARGS_3, + _INIT_CALL_PY_EXACT_ARGS_4, + _INSERT_NULL, + _IS_NONE, + _IS_OP, + _ITER_CHECK_LIST, + _ITER_CHECK_RANGE, + _ITER_CHECK_TUPLE, + _ITER_JUMP_LIST, + _ITER_JUMP_RANGE, + _ITER_JUMP_TUPLE, + _ITER_NEXT_INLINE, + _ITER_NEXT_LIST, + _ITER_NEXT_LIST_TIER_TWO, + _ITER_NEXT_RANGE, + _ITER_NEXT_TUPLE, + _JUMP_TO_TOP, + _LIST_EXTEND, + _LOAD_ATTR, + _LOAD_ATTR_CLASS, + _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME, + _LOAD_ATTR_INSTANCE_VALUE, + _LOAD_ATTR_METHOD_LAZY_DICT, + _LOAD_ATTR_METHOD_NO_DICT, + _LOAD_ATTR_METHOD_WITH_VALUES, + _LOAD_ATTR_MODULE, + _LOAD_ATTR_NONDESCRIPTOR_NO_DICT, + _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES, + _LOAD_ATTR_PROPERTY_FRAME, + _LOAD_ATTR_SLOT, + _LOAD_ATTR_WITH_HINT, + _LOAD_BYTECODE, + _LOAD_CONST_INLINE, + _LOAD_CONST_INLINE_BORROW, + _LOAD_FAST, + _LOAD_FAST_0, + _LOAD_FAST_1, + _LOAD_FAST_2, + _LOAD_FAST_3, + _LOAD_FAST_4, + _LOAD_FAST_5, + _LOAD_FAST_6, + _LOAD_FAST_7, + _LOAD_FAST_BORROW, + _LOAD_FAST_BORROW_0, + _LOAD_FAST_BORROW_1, + _LOAD_FAST_BORROW_2, + _LOAD_FAST_BORROW_3, + _LOAD_FAST_BORROW_4, + _LOAD_FAST_BORROW_5, + _LOAD_FAST_BORROW_6, + _LOAD_FAST_BORROW_7, + _LOAD_GLOBAL, + _LOAD_GLOBAL_BUILTINS, + _LOAD_GLOBAL_MODULE, + _LOAD_SMALL_INT, + _LOAD_SMALL_INT_0, + _LOAD_SMALL_INT_1, + _LOAD_SMALL_INT_2, + _LOAD_SMALL_INT_3, + _LOAD_SPECIAL, + _LOAD_SUPER_ATTR_METHOD, + _LOCK_OBJECT, + _MAKE_CALLARGS_A_TUPLE, + _MAKE_FUNCTION, + _MAKE_HEAP_SAFE, + _MAKE_WARM, + _MATCH_CLASS, + _MAYBE_EXPAND_METHOD, + _MAYBE_EXPAND_METHOD_KW, + _MONITOR_CALL, + _MONITOR_CALL_KW, + _MONITOR_JUMP_BACKWARD, + _MONITOR_RESUME, + _POP_JUMP_IF_FALSE, + _POP_JUMP_IF_TRUE, + _POP_TOP_FLOAT, + _POP_TOP_INT, + _POP_TOP_NOP, + _POP_TOP_OPARG, + _POP_TOP_UNICODE, + _PUSH_FRAME, + _PUSH_NULL_CONDITIONAL, + _PUSH_TAGGED_ZERO, + _PY_FRAME_EX, + _PY_FRAME_GENERAL, + _PY_FRAME_KW, + _RECORD_3OS_GEN_FUNC, + _RECORD_4OS, + _RECORD_BOUND_METHOD, + _RECORD_CALLABLE, + _RECORD_CALLABLE_KW, + _RECORD_CODE, + _RECORD_NOS, + _RECORD_NOS_GEN_FUNC, + _RECORD_NOS_TYPE, + _RECORD_TOS, + _RECORD_TOS_TYPE, + _REPLACE_WITH_TRUE, + _RESUME_CHECK, + _RETURN_VALUE, + _RROT_3, + _SAVE_RETURN_OFFSET, + _SEND_ASYNC_GEN, + _SEND_ASYNC_GEN_TIER_TWO, + _SEND_GEN_FRAME, + _SEND_VIRTUAL, + _SEND_VIRTUAL_TIER_TWO, + _SET_UPDATE, + _SPILL_OR_RELOAD, + _START_EXECUTOR, + _STORE_ATTR, + _STORE_ATTR_INSTANCE_VALUE, + _STORE_ATTR_SLOT, + _STORE_ATTR_WITH_HINT, + _STORE_SLICE, + _STORE_SUBSCR, + _STORE_SUBSCR_DICT, + _STORE_SUBSCR_DICT_KNOWN_HASH, + _STORE_SUBSCR_LIST_INT, + _SWAP, + _SWAP_2, + _SWAP_3, + _SWAP_FAST, + _SWAP_FAST_0, + _SWAP_FAST_1, + _SWAP_FAST_2, + _SWAP_FAST_3, + _SWAP_FAST_4, + _SWAP_FAST_5, + _SWAP_FAST_6, + _SWAP_FAST_7, + _TIER2_RESUME_CHECK, + _TO_BOOL, + _TO_BOOL_INT, + _TO_BOOL_LIST, + _TO_BOOL_STR, + _UNARY_INVERT, + _UNARY_NEGATIVE, + _UNARY_NEGATIVE_FLOAT_INPLACE, + _UNPACK_SEQUENCE, + _UNPACK_SEQUENCE_LIST, + _UNPACK_SEQUENCE_TUPLE, + _UNPACK_SEQUENCE_TWO_TUPLE, + _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE, + _UNPACK_SEQUENCE_UNIQUE_TUPLE, + _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE, + _YIELD_VALUE, +}; +#define MAX_UOP_ID 652 + #define _BUILD_INTERPOLATION BUILD_INTERPOLATION #define _BUILD_LIST BUILD_LIST #define _BUILD_MAP BUILD_MAP @@ -55,194 +374,24 @@ extern "C" { #define _BUILD_STRING BUILD_STRING #define _BUILD_TEMPLATE BUILD_TEMPLATE #define _BUILD_TUPLE BUILD_TUPLE -#define _CALL_BUILTIN_CLASS 338 -#define _CALL_BUILTIN_FAST 339 -#define _CALL_BUILTIN_FAST_WITH_KEYWORDS 340 -#define _CALL_BUILTIN_O 341 -#define _CALL_FUNCTION_EX_NON_PY_GENERAL 342 -#define _CALL_INTRINSIC_1 343 -#define _CALL_INTRINSIC_2 344 -#define _CALL_ISINSTANCE 345 -#define _CALL_KW_NON_PY 346 -#define _CALL_LEN 347 -#define _CALL_LIST_APPEND 348 -#define _CALL_METHOD_DESCRIPTOR_FAST 349 -#define _CALL_METHOD_DESCRIPTOR_FAST_INLINE 350 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 351 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE 352 -#define _CALL_METHOD_DESCRIPTOR_NOARGS 353 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE 354 -#define _CALL_METHOD_DESCRIPTOR_O 355 -#define _CALL_METHOD_DESCRIPTOR_O_INLINE 356 -#define _CALL_NON_PY_GENERAL 357 -#define _CALL_STR_1 358 -#define _CALL_TUPLE_1 359 -#define _CALL_TYPE_1 360 -#define _CHECK_ATTR_CLASS 361 -#define _CHECK_ATTR_METHOD_LAZY_DICT 362 -#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS 363 #define _CHECK_EG_MATCH CHECK_EG_MATCH #define _CHECK_EXC_MATCH CHECK_EXC_MATCH -#define _CHECK_FUNCTION_EXACT_ARGS 364 -#define _CHECK_FUNCTION_VERSION 365 -#define _CHECK_FUNCTION_VERSION_INLINE 366 -#define _CHECK_FUNCTION_VERSION_KW 367 -#define _CHECK_IS_NOT_PY_CALLABLE 368 -#define _CHECK_IS_NOT_PY_CALLABLE_EX 369 -#define _CHECK_IS_NOT_PY_CALLABLE_KW 370 -#define _CHECK_IS_PY_CALLABLE_EX 371 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES 372 -#define _CHECK_METHOD_VERSION 373 -#define _CHECK_METHOD_VERSION_KW 374 -#define _CHECK_OBJECT 375 -#define _CHECK_PEP_523 376 -#define _CHECK_PERIODIC 377 -#define _CHECK_PERIODIC_AT_END 378 -#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM 379 -#define _CHECK_RECURSION_LIMIT 380 -#define _CHECK_RECURSION_REMAINING 381 -#define _CHECK_STACK_SPACE 382 -#define _CHECK_STACK_SPACE_OPERAND 383 -#define _CHECK_VALIDITY 384 -#define _COLD_DYNAMIC_EXIT 385 -#define _COLD_EXIT 386 -#define _COMPARE_OP 387 -#define _COMPARE_OP_FLOAT 388 -#define _COMPARE_OP_INT 389 -#define _COMPARE_OP_STR 390 -#define _CONTAINS_OP 391 -#define _CONTAINS_OP_DICT 392 -#define _CONTAINS_OP_SET 393 #define _CONVERT_VALUE CONVERT_VALUE -#define _COPY 394 -#define _COPY_1 395 -#define _COPY_2 396 -#define _COPY_3 397 #define _COPY_FREE_VARS COPY_FREE_VARS -#define _CREATE_INIT_FRAME 398 #define _DELETE_DEREF DELETE_DEREF #define _DELETE_FAST DELETE_FAST #define _DELETE_SUBSCR DELETE_SUBSCR -#define _DEOPT 399 -#define _DICT_MERGE 400 -#define _DICT_UPDATE 401 -#define _DO_CALL 402 -#define _DO_CALL_FUNCTION_EX 403 -#define _DO_CALL_KW 404 -#define _DYNAMIC_EXIT 405 #define _END_FOR END_FOR #define _END_SEND END_SEND -#define _ERROR_POP_N 406 #define _EXIT_INIT_CHECK EXIT_INIT_CHECK -#define _EXPAND_METHOD 407 -#define _EXPAND_METHOD_KW 408 -#define _FATAL_ERROR 409 #define _FORMAT_SIMPLE FORMAT_SIMPLE #define _FORMAT_WITH_SPEC FORMAT_WITH_SPEC -#define _FOR_ITER 410 -#define _FOR_ITER_GEN_FRAME 411 -#define _FOR_ITER_TIER_TWO 412 -#define _FOR_ITER_VIRTUAL 413 -#define _FOR_ITER_VIRTUAL_TIER_TWO 414 #define _GET_AITER GET_AITER #define _GET_ANEXT GET_ANEXT #define _GET_AWAITABLE GET_AWAITABLE -#define _GET_ITER 415 -#define _GET_ITER_TRAD 416 #define _GET_LEN GET_LEN -#define _GUARD_3OS_ASYNC_GEN_ASEND 417 -#define _GUARD_BINARY_OP_EXTEND 418 -#define _GUARD_BINARY_OP_EXTEND_LHS 419 -#define _GUARD_BINARY_OP_EXTEND_RHS 420 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS 421 -#define _GUARD_BIT_IS_SET_POP 422 -#define _GUARD_BIT_IS_SET_POP_4 423 -#define _GUARD_BIT_IS_SET_POP_5 424 -#define _GUARD_BIT_IS_SET_POP_6 425 -#define _GUARD_BIT_IS_SET_POP_7 426 -#define _GUARD_BIT_IS_UNSET_POP 427 -#define _GUARD_BIT_IS_UNSET_POP_4 428 -#define _GUARD_BIT_IS_UNSET_POP_5 429 -#define _GUARD_BIT_IS_UNSET_POP_6 430 -#define _GUARD_BIT_IS_UNSET_POP_7 431 -#define _GUARD_CALLABLE_BUILTIN_CLASS 432 -#define _GUARD_CALLABLE_BUILTIN_FAST 433 -#define _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS 434 -#define _GUARD_CALLABLE_BUILTIN_O 435 -#define _GUARD_CALLABLE_ISINSTANCE 436 -#define _GUARD_CALLABLE_LEN 437 -#define _GUARD_CALLABLE_LIST_APPEND 438 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST 439 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 440 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS 441 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_O 442 -#define _GUARD_CALLABLE_STR_1 443 -#define _GUARD_CALLABLE_TUPLE_1 444 -#define _GUARD_CALLABLE_TYPE_1 445 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR 446 -#define _GUARD_CODE_VERSION_RETURN_VALUE 447 -#define _GUARD_CODE_VERSION_YIELD_VALUE 448 -#define _GUARD_CODE_VERSION__PUSH_FRAME 449 -#define _GUARD_DORV_NO_DICT 450 -#define _GUARD_GLOBALS_VERSION 451 -#define _GUARD_IP_RETURN_GENERATOR 452 -#define _GUARD_IP_RETURN_VALUE 453 -#define _GUARD_IP_YIELD_VALUE 454 -#define _GUARD_IP__PUSH_FRAME 455 -#define _GUARD_IS_FALSE_POP 456 -#define _GUARD_IS_NONE_POP 457 -#define _GUARD_IS_NOT_NONE_POP 458 -#define _GUARD_IS_TRUE_POP 459 -#define _GUARD_ITERATOR 460 -#define _GUARD_ITER_VIRTUAL 461 -#define _GUARD_LOAD_SUPER_ATTR_METHOD 462 -#define _GUARD_NOS_COMPACT_ASCII 463 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT 464 -#define _GUARD_NOS_DICT_SUBSCRIPT 465 -#define _GUARD_NOS_FLOAT 466 -#define _GUARD_NOS_INT 467 -#define _GUARD_NOS_ITER_VIRTUAL 468 -#define _GUARD_NOS_LIST 469 -#define _GUARD_NOS_NOT_NULL 470 -#define _GUARD_NOS_NULL 471 -#define _GUARD_NOS_OVERFLOWED 472 -#define _GUARD_NOS_TUPLE 473 -#define _GUARD_NOS_TYPE_VERSION 474 -#define _GUARD_NOS_UNICODE 475 -#define _GUARD_NOT_EXHAUSTED_LIST 476 -#define _GUARD_NOT_EXHAUSTED_RANGE 477 -#define _GUARD_NOT_EXHAUSTED_TUPLE 478 -#define _GUARD_THIRD_NULL 479 -#define _GUARD_TOS_ANY_DICT 480 -#define _GUARD_TOS_ANY_SET 481 -#define _GUARD_TOS_DICT 482 -#define _GUARD_TOS_FLOAT 483 -#define _GUARD_TOS_FROZENDICT 484 -#define _GUARD_TOS_FROZENSET 485 -#define _GUARD_TOS_INT 486 -#define _GUARD_TOS_IS_NONE 487 -#define _GUARD_TOS_LIST 488 -#define _GUARD_TOS_NOT_NULL 489 -#define _GUARD_TOS_OVERFLOWED 490 -#define _GUARD_TOS_SET 491 -#define _GUARD_TOS_SLICE 492 -#define _GUARD_TOS_TUPLE 493 -#define _GUARD_TOS_UNICODE 494 -#define _GUARD_TYPE 495 -#define _GUARD_TYPE_ITER 496 -#define _GUARD_TYPE_VERSION 497 -#define _GUARD_TYPE_VERSION_LOCKED 498 -#define _HANDLE_PENDING_AND_DEOPT 499 #define _IMPORT_FROM IMPORT_FROM #define _IMPORT_NAME IMPORT_NAME -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 500 -#define _INIT_CALL_PY_EXACT_ARGS 501 -#define _INIT_CALL_PY_EXACT_ARGS_0 502 -#define _INIT_CALL_PY_EXACT_ARGS_1 503 -#define _INIT_CALL_PY_EXACT_ARGS_2 504 -#define _INIT_CALL_PY_EXACT_ARGS_3 505 -#define _INIT_CALL_PY_EXACT_ARGS_4 506 -#define _INSERT_NULL 507 #define _INSTRUMENTED_FOR_ITER INSTRUMENTED_FOR_ITER #define _INSTRUMENTED_INSTRUCTION INSTRUMENTED_INSTRUCTION #define _INSTRUMENTED_JUMP_FORWARD INSTRUMENTED_JUMP_FORWARD @@ -252,1182 +401,1039 @@ extern "C" { #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 508 -#define _IS_OP 509 -#define _ITER_CHECK_LIST 510 -#define _ITER_CHECK_RANGE 511 -#define _ITER_CHECK_TUPLE 512 -#define _ITER_JUMP_LIST 513 -#define _ITER_JUMP_RANGE 514 -#define _ITER_JUMP_TUPLE 515 -#define _ITER_NEXT_INLINE 516 -#define _ITER_NEXT_LIST 517 -#define _ITER_NEXT_LIST_TIER_TWO 518 -#define _ITER_NEXT_RANGE 519 -#define _ITER_NEXT_TUPLE 520 #define _JUMP_BACKWARD_NO_INTERRUPT JUMP_BACKWARD_NO_INTERRUPT -#define _JUMP_TO_TOP 521 #define _LIST_APPEND LIST_APPEND -#define _LIST_EXTEND 522 -#define _LOAD_ATTR 523 -#define _LOAD_ATTR_CLASS 524 -#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME 525 -#define _LOAD_ATTR_INSTANCE_VALUE 526 -#define _LOAD_ATTR_METHOD_LAZY_DICT 527 -#define _LOAD_ATTR_METHOD_NO_DICT 528 -#define _LOAD_ATTR_METHOD_WITH_VALUES 529 -#define _LOAD_ATTR_MODULE 530 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 531 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 532 -#define _LOAD_ATTR_PROPERTY_FRAME 533 -#define _LOAD_ATTR_SLOT 534 -#define _LOAD_ATTR_WITH_HINT 535 #define _LOAD_BUILD_CLASS LOAD_BUILD_CLASS -#define _LOAD_BYTECODE 536 #define _LOAD_COMMON_CONSTANT LOAD_COMMON_CONSTANT #define _LOAD_CONST LOAD_CONST -#define _LOAD_CONST_INLINE 537 -#define _LOAD_CONST_INLINE_BORROW 538 #define _LOAD_DEREF LOAD_DEREF -#define _LOAD_FAST 539 -#define _LOAD_FAST_0 540 -#define _LOAD_FAST_1 541 -#define _LOAD_FAST_2 542 -#define _LOAD_FAST_3 543 -#define _LOAD_FAST_4 544 -#define _LOAD_FAST_5 545 -#define _LOAD_FAST_6 546 -#define _LOAD_FAST_7 547 #define _LOAD_FAST_AND_CLEAR LOAD_FAST_AND_CLEAR -#define _LOAD_FAST_BORROW 548 -#define _LOAD_FAST_BORROW_0 549 -#define _LOAD_FAST_BORROW_1 550 -#define _LOAD_FAST_BORROW_2 551 -#define _LOAD_FAST_BORROW_3 552 -#define _LOAD_FAST_BORROW_4 553 -#define _LOAD_FAST_BORROW_5 554 -#define _LOAD_FAST_BORROW_6 555 -#define _LOAD_FAST_BORROW_7 556 #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 557 -#define _LOAD_GLOBAL_BUILTINS 558 -#define _LOAD_GLOBAL_MODULE 559 #define _LOAD_LOCALS LOAD_LOCALS #define _LOAD_NAME LOAD_NAME -#define _LOAD_SMALL_INT 560 -#define _LOAD_SMALL_INT_0 561 -#define _LOAD_SMALL_INT_1 562 -#define _LOAD_SMALL_INT_2 563 -#define _LOAD_SMALL_INT_3 564 -#define _LOAD_SPECIAL 565 #define _LOAD_SUPER_ATTR_ATTR LOAD_SUPER_ATTR_ATTR -#define _LOAD_SUPER_ATTR_METHOD 566 -#define _LOCK_OBJECT 567 -#define _MAKE_CALLARGS_A_TUPLE 568 #define _MAKE_CELL MAKE_CELL -#define _MAKE_FUNCTION 569 -#define _MAKE_HEAP_SAFE 570 -#define _MAKE_WARM 571 #define _MAP_ADD MAP_ADD -#define _MATCH_CLASS 572 #define _MATCH_KEYS MATCH_KEYS #define _MATCH_MAPPING MATCH_MAPPING #define _MATCH_SEQUENCE MATCH_SEQUENCE -#define _MAYBE_EXPAND_METHOD 573 -#define _MAYBE_EXPAND_METHOD_KW 574 -#define _MONITOR_CALL 575 -#define _MONITOR_CALL_KW 576 -#define _MONITOR_JUMP_BACKWARD 577 -#define _MONITOR_RESUME 578 #define _NOP NOP #define _POP_EXCEPT POP_EXCEPT #define _POP_ITER POP_ITER -#define _POP_JUMP_IF_FALSE 579 -#define _POP_JUMP_IF_TRUE 580 #define _POP_TOP POP_TOP -#define _POP_TOP_FLOAT 581 -#define _POP_TOP_INT 582 -#define _POP_TOP_NOP 583 -#define _POP_TOP_OPARG 584 -#define _POP_TOP_UNICODE 585 #define _PUSH_EXC_INFO PUSH_EXC_INFO -#define _PUSH_FRAME 586 #define _PUSH_NULL PUSH_NULL -#define _PUSH_NULL_CONDITIONAL 587 -#define _PUSH_TAGGED_ZERO 588 -#define _PY_FRAME_EX 589 -#define _PY_FRAME_GENERAL 590 -#define _PY_FRAME_KW 591 -#define _RECORD_3OS_GEN_FUNC 592 -#define _RECORD_4OS 593 -#define _RECORD_BOUND_METHOD 594 -#define _RECORD_CALLABLE 595 -#define _RECORD_CALLABLE_KW 596 -#define _RECORD_CODE 597 -#define _RECORD_NOS 598 -#define _RECORD_NOS_GEN_FUNC 599 -#define _RECORD_NOS_TYPE 600 -#define _RECORD_TOS 601 -#define _RECORD_TOS_TYPE 602 -#define _REPLACE_WITH_TRUE 603 -#define _RESUME_CHECK 604 #define _RETURN_GENERATOR RETURN_GENERATOR -#define _RETURN_VALUE 605 -#define _RROT_3 606 -#define _SAVE_RETURN_OFFSET 607 -#define _SEND_ASYNC_GEN 608 -#define _SEND_ASYNC_GEN_TIER_TWO 609 -#define _SEND_GEN_FRAME 610 -#define _SEND_VIRTUAL 611 -#define _SEND_VIRTUAL_TIER_TWO 612 #define _SETUP_ANNOTATIONS SETUP_ANNOTATIONS #define _SET_ADD SET_ADD #define _SET_FUNCTION_ATTRIBUTE SET_FUNCTION_ATTRIBUTE -#define _SET_UPDATE 613 -#define _SPILL_OR_RELOAD 614 -#define _START_EXECUTOR 615 -#define _STORE_ATTR 616 -#define _STORE_ATTR_INSTANCE_VALUE 617 -#define _STORE_ATTR_SLOT 618 -#define _STORE_ATTR_WITH_HINT 619 #define _STORE_DEREF STORE_DEREF #define _STORE_GLOBAL STORE_GLOBAL #define _STORE_NAME STORE_NAME -#define _STORE_SLICE 620 -#define _STORE_SUBSCR 621 -#define _STORE_SUBSCR_DICT 622 -#define _STORE_SUBSCR_DICT_KNOWN_HASH 623 -#define _STORE_SUBSCR_LIST_INT 624 -#define _SWAP 625 -#define _SWAP_2 626 -#define _SWAP_3 627 -#define _SWAP_FAST 628 -#define _SWAP_FAST_0 629 -#define _SWAP_FAST_1 630 -#define _SWAP_FAST_2 631 -#define _SWAP_FAST_3 632 -#define _SWAP_FAST_4 633 -#define _SWAP_FAST_5 634 -#define _SWAP_FAST_6 635 -#define _SWAP_FAST_7 636 -#define _TIER2_RESUME_CHECK 637 -#define _TO_BOOL 638 #define _TO_BOOL_BOOL TO_BOOL_BOOL -#define _TO_BOOL_INT 639 -#define _TO_BOOL_LIST 640 #define _TO_BOOL_NONE TO_BOOL_NONE -#define _TO_BOOL_STR 641 #define _TRACE_RECORD TRACE_RECORD -#define _UNARY_INVERT 642 -#define _UNARY_NEGATIVE 643 -#define _UNARY_NEGATIVE_FLOAT_INPLACE 644 #define _UNARY_NOT UNARY_NOT #define _UNPACK_EX UNPACK_EX -#define _UNPACK_SEQUENCE 645 -#define _UNPACK_SEQUENCE_LIST 646 -#define _UNPACK_SEQUENCE_TUPLE 647 -#define _UNPACK_SEQUENCE_TWO_TUPLE 648 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE 649 -#define _UNPACK_SEQUENCE_UNIQUE_TUPLE 650 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE 651 #define _WITH_EXCEPT_START WITH_EXCEPT_START -#define _YIELD_VALUE 652 -#define MAX_UOP_ID 652 -#define _ALLOCATE_OBJECT_r00 653 -#define _BINARY_OP_r23 654 -#define _BINARY_OP_ADD_FLOAT_r03 655 -#define _BINARY_OP_ADD_FLOAT_r13 656 -#define _BINARY_OP_ADD_FLOAT_r23 657 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r03 658 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r13 659 -#define _BINARY_OP_ADD_FLOAT_INPLACE_r23 660 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r03 661 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r13 662 -#define _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r23 663 -#define _BINARY_OP_ADD_INT_r03 664 -#define _BINARY_OP_ADD_INT_r13 665 -#define _BINARY_OP_ADD_INT_r23 666 -#define _BINARY_OP_ADD_INT_INPLACE_r03 667 -#define _BINARY_OP_ADD_INT_INPLACE_r13 668 -#define _BINARY_OP_ADD_INT_INPLACE_r23 669 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r03 670 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r13 671 -#define _BINARY_OP_ADD_INT_INPLACE_RIGHT_r23 672 -#define _BINARY_OP_ADD_UNICODE_r03 673 -#define _BINARY_OP_ADD_UNICODE_r13 674 -#define _BINARY_OP_ADD_UNICODE_r23 675 -#define _BINARY_OP_EXTEND_r23 676 -#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 677 -#define _BINARY_OP_MULTIPLY_FLOAT_r03 678 -#define _BINARY_OP_MULTIPLY_FLOAT_r13 679 -#define _BINARY_OP_MULTIPLY_FLOAT_r23 680 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r03 681 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r13 682 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r23 683 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r03 684 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r13 685 -#define _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r23 686 -#define _BINARY_OP_MULTIPLY_INT_r03 687 -#define _BINARY_OP_MULTIPLY_INT_r13 688 -#define _BINARY_OP_MULTIPLY_INT_r23 689 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r03 690 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r13 691 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_r23 692 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r03 693 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r13 694 -#define _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r23 695 -#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 696 -#define _BINARY_OP_SUBSCR_DICT_r23 697 -#define _BINARY_OP_SUBSCR_DICT_KNOWN_HASH_r23 698 -#define _BINARY_OP_SUBSCR_INIT_CALL_r01 699 -#define _BINARY_OP_SUBSCR_INIT_CALL_r11 700 -#define _BINARY_OP_SUBSCR_INIT_CALL_r21 701 -#define _BINARY_OP_SUBSCR_INIT_CALL_r31 702 -#define _BINARY_OP_SUBSCR_LIST_INT_r23 703 -#define _BINARY_OP_SUBSCR_LIST_SLICE_r23 704 -#define _BINARY_OP_SUBSCR_STR_INT_r23 705 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 706 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 707 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 708 -#define _BINARY_OP_SUBSCR_USTR_INT_r23 709 -#define _BINARY_OP_SUBTRACT_FLOAT_r03 710 -#define _BINARY_OP_SUBTRACT_FLOAT_r13 711 -#define _BINARY_OP_SUBTRACT_FLOAT_r23 712 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r03 713 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r13 714 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r23 715 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r03 716 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r13 717 -#define _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r23 718 -#define _BINARY_OP_SUBTRACT_INT_r03 719 -#define _BINARY_OP_SUBTRACT_INT_r13 720 -#define _BINARY_OP_SUBTRACT_INT_r23 721 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r03 722 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r13 723 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_r23 724 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r03 725 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r13 726 -#define _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r23 727 -#define _BINARY_OP_TRUEDIV_FLOAT_r23 728 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r03 729 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r13 730 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r23 731 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r03 732 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r13 733 -#define _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23 734 -#define _BINARY_SLICE_r31 735 -#define _BUILD_INTERPOLATION_r01 736 -#define _BUILD_LIST_r01 737 -#define _BUILD_MAP_r01 738 -#define _BUILD_SET_r01 739 -#define _BUILD_SLICE_r01 740 -#define _BUILD_STRING_r01 741 -#define _BUILD_TEMPLATE_r21 742 -#define _BUILD_TUPLE_r01 743 -#define _CALL_BUILTIN_CLASS_r00 744 -#define _CALL_BUILTIN_FAST_r00 745 -#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r00 746 -#define _CALL_BUILTIN_O_r03 747 -#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 748 -#define _CALL_INTRINSIC_1_r12 749 -#define _CALL_INTRINSIC_2_r23 750 -#define _CALL_ISINSTANCE_r31 751 -#define _CALL_KW_NON_PY_r11 752 -#define _CALL_LEN_r33 753 -#define _CALL_LIST_APPEND_r03 754 -#define _CALL_LIST_APPEND_r13 755 -#define _CALL_LIST_APPEND_r23 756 -#define _CALL_LIST_APPEND_r33 757 -#define _CALL_METHOD_DESCRIPTOR_FAST_r00 758 -#define _CALL_METHOD_DESCRIPTOR_FAST_INLINE_r00 759 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 760 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE_r00 761 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_r03 762 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE_r03 763 -#define _CALL_METHOD_DESCRIPTOR_O_r03 764 -#define _CALL_METHOD_DESCRIPTOR_O_INLINE_r03 765 -#define _CALL_NON_PY_GENERAL_r01 766 -#define _CALL_STR_1_r32 767 -#define _CALL_TUPLE_1_r32 768 -#define _CALL_TYPE_1_r02 769 -#define _CALL_TYPE_1_r12 770 -#define _CALL_TYPE_1_r22 771 -#define _CALL_TYPE_1_r32 772 -#define _CHECK_ATTR_CLASS_r01 773 -#define _CHECK_ATTR_CLASS_r11 774 -#define _CHECK_ATTR_CLASS_r22 775 -#define _CHECK_ATTR_CLASS_r33 776 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 777 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 778 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 779 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 780 -#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 781 -#define _CHECK_EG_MATCH_r22 782 -#define _CHECK_EXC_MATCH_r22 783 -#define _CHECK_FUNCTION_EXACT_ARGS_r00 784 -#define _CHECK_FUNCTION_VERSION_r00 785 -#define _CHECK_FUNCTION_VERSION_INLINE_r00 786 -#define _CHECK_FUNCTION_VERSION_INLINE_r11 787 -#define _CHECK_FUNCTION_VERSION_INLINE_r22 788 -#define _CHECK_FUNCTION_VERSION_INLINE_r33 789 -#define _CHECK_FUNCTION_VERSION_KW_r11 790 -#define _CHECK_IS_NOT_PY_CALLABLE_r00 791 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 792 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 793 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 794 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 795 -#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 796 -#define _CHECK_IS_PY_CALLABLE_EX_r03 797 -#define _CHECK_IS_PY_CALLABLE_EX_r13 798 -#define _CHECK_IS_PY_CALLABLE_EX_r23 799 -#define _CHECK_IS_PY_CALLABLE_EX_r33 800 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 801 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 802 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 803 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 804 -#define _CHECK_METHOD_VERSION_r00 805 -#define _CHECK_METHOD_VERSION_KW_r11 806 -#define _CHECK_OBJECT_r00 807 -#define _CHECK_PEP_523_r00 808 -#define _CHECK_PEP_523_r11 809 -#define _CHECK_PEP_523_r22 810 -#define _CHECK_PEP_523_r33 811 -#define _CHECK_PERIODIC_r00 812 -#define _CHECK_PERIODIC_AT_END_r00 813 -#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 814 -#define _CHECK_RECURSION_LIMIT_r00 815 -#define _CHECK_RECURSION_LIMIT_r11 816 -#define _CHECK_RECURSION_LIMIT_r22 817 -#define _CHECK_RECURSION_LIMIT_r33 818 -#define _CHECK_RECURSION_REMAINING_r00 819 -#define _CHECK_RECURSION_REMAINING_r11 820 -#define _CHECK_RECURSION_REMAINING_r22 821 -#define _CHECK_RECURSION_REMAINING_r33 822 -#define _CHECK_STACK_SPACE_r00 823 -#define _CHECK_STACK_SPACE_OPERAND_r00 824 -#define _CHECK_STACK_SPACE_OPERAND_r11 825 -#define _CHECK_STACK_SPACE_OPERAND_r22 826 -#define _CHECK_STACK_SPACE_OPERAND_r33 827 -#define _CHECK_VALIDITY_r00 828 -#define _CHECK_VALIDITY_r11 829 -#define _CHECK_VALIDITY_r22 830 -#define _CHECK_VALIDITY_r33 831 -#define _COLD_DYNAMIC_EXIT_r00 832 -#define _COLD_EXIT_r00 833 -#define _COMPARE_OP_r21 834 -#define _COMPARE_OP_FLOAT_r03 835 -#define _COMPARE_OP_FLOAT_r13 836 -#define _COMPARE_OP_FLOAT_r23 837 -#define _COMPARE_OP_INT_r23 838 -#define _COMPARE_OP_STR_r23 839 -#define _CONTAINS_OP_r23 840 -#define _CONTAINS_OP_DICT_r23 841 -#define _CONTAINS_OP_SET_r23 842 -#define _CONVERT_VALUE_r11 843 -#define _COPY_r01 844 -#define _COPY_1_r02 845 -#define _COPY_1_r12 846 -#define _COPY_1_r23 847 -#define _COPY_2_r03 848 -#define _COPY_2_r13 849 -#define _COPY_2_r23 850 -#define _COPY_3_r03 851 -#define _COPY_3_r13 852 -#define _COPY_3_r23 853 -#define _COPY_3_r33 854 -#define _COPY_FREE_VARS_r00 855 -#define _COPY_FREE_VARS_r11 856 -#define _COPY_FREE_VARS_r22 857 -#define _COPY_FREE_VARS_r33 858 -#define _CREATE_INIT_FRAME_r01 859 -#define _DELETE_DEREF_r00 860 -#define _DELETE_FAST_r00 861 -#define _DELETE_SUBSCR_r20 862 -#define _DEOPT_r00 863 -#define _DEOPT_r10 864 -#define _DEOPT_r20 865 -#define _DEOPT_r30 866 -#define _DICT_MERGE_r11 867 -#define _DICT_UPDATE_r11 868 -#define _DO_CALL_r01 869 -#define _DO_CALL_FUNCTION_EX_r31 870 -#define _DO_CALL_KW_r11 871 -#define _DYNAMIC_EXIT_r00 872 -#define _DYNAMIC_EXIT_r10 873 -#define _DYNAMIC_EXIT_r20 874 -#define _DYNAMIC_EXIT_r30 875 -#define _END_FOR_r10 876 -#define _END_SEND_r31 877 -#define _ERROR_POP_N_r00 878 -#define _EXIT_INIT_CHECK_r10 879 -#define _EXIT_TRACE_r00 880 -#define _EXIT_TRACE_r10 881 -#define _EXIT_TRACE_r20 882 -#define _EXIT_TRACE_r30 883 -#define _EXPAND_METHOD_r00 884 -#define _EXPAND_METHOD_KW_r11 885 -#define _FATAL_ERROR_r00 886 -#define _FATAL_ERROR_r11 887 -#define _FATAL_ERROR_r22 888 -#define _FATAL_ERROR_r33 889 -#define _FORMAT_SIMPLE_r11 890 -#define _FORMAT_WITH_SPEC_r21 891 -#define _FOR_ITER_r23 892 -#define _FOR_ITER_GEN_FRAME_r03 893 -#define _FOR_ITER_GEN_FRAME_r13 894 -#define _FOR_ITER_GEN_FRAME_r23 895 -#define _FOR_ITER_TIER_TWO_r23 896 -#define _FOR_ITER_VIRTUAL_r23 897 -#define _FOR_ITER_VIRTUAL_TIER_TWO_r23 898 -#define _GET_AITER_r11 899 -#define _GET_ANEXT_r12 900 -#define _GET_AWAITABLE_r11 901 -#define _GET_ITER_r12 902 -#define _GET_ITER_TRAD_r12 903 -#define _GET_LEN_r12 904 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r03 905 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r13 906 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r23 907 -#define _GUARD_3OS_ASYNC_GEN_ASEND_r33 908 -#define _GUARD_BINARY_OP_EXTEND_r22 909 -#define _GUARD_BINARY_OP_EXTEND_LHS_r02 910 -#define _GUARD_BINARY_OP_EXTEND_LHS_r12 911 -#define _GUARD_BINARY_OP_EXTEND_LHS_r22 912 -#define _GUARD_BINARY_OP_EXTEND_LHS_r33 913 -#define _GUARD_BINARY_OP_EXTEND_RHS_r02 914 -#define _GUARD_BINARY_OP_EXTEND_RHS_r12 915 -#define _GUARD_BINARY_OP_EXTEND_RHS_r22 916 -#define _GUARD_BINARY_OP_EXTEND_RHS_r33 917 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 918 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 919 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 920 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 921 -#define _GUARD_BIT_IS_SET_POP_r00 922 -#define _GUARD_BIT_IS_SET_POP_r10 923 -#define _GUARD_BIT_IS_SET_POP_r21 924 -#define _GUARD_BIT_IS_SET_POP_r32 925 -#define _GUARD_BIT_IS_SET_POP_4_r00 926 -#define _GUARD_BIT_IS_SET_POP_4_r10 927 -#define _GUARD_BIT_IS_SET_POP_4_r21 928 -#define _GUARD_BIT_IS_SET_POP_4_r32 929 -#define _GUARD_BIT_IS_SET_POP_5_r00 930 -#define _GUARD_BIT_IS_SET_POP_5_r10 931 -#define _GUARD_BIT_IS_SET_POP_5_r21 932 -#define _GUARD_BIT_IS_SET_POP_5_r32 933 -#define _GUARD_BIT_IS_SET_POP_6_r00 934 -#define _GUARD_BIT_IS_SET_POP_6_r10 935 -#define _GUARD_BIT_IS_SET_POP_6_r21 936 -#define _GUARD_BIT_IS_SET_POP_6_r32 937 -#define _GUARD_BIT_IS_SET_POP_7_r00 938 -#define _GUARD_BIT_IS_SET_POP_7_r10 939 -#define _GUARD_BIT_IS_SET_POP_7_r21 940 -#define _GUARD_BIT_IS_SET_POP_7_r32 941 -#define _GUARD_BIT_IS_UNSET_POP_r00 942 -#define _GUARD_BIT_IS_UNSET_POP_r10 943 -#define _GUARD_BIT_IS_UNSET_POP_r21 944 -#define _GUARD_BIT_IS_UNSET_POP_r32 945 -#define _GUARD_BIT_IS_UNSET_POP_4_r00 946 -#define _GUARD_BIT_IS_UNSET_POP_4_r10 947 -#define _GUARD_BIT_IS_UNSET_POP_4_r21 948 -#define _GUARD_BIT_IS_UNSET_POP_4_r32 949 -#define _GUARD_BIT_IS_UNSET_POP_5_r00 950 -#define _GUARD_BIT_IS_UNSET_POP_5_r10 951 -#define _GUARD_BIT_IS_UNSET_POP_5_r21 952 -#define _GUARD_BIT_IS_UNSET_POP_5_r32 953 -#define _GUARD_BIT_IS_UNSET_POP_6_r00 954 -#define _GUARD_BIT_IS_UNSET_POP_6_r10 955 -#define _GUARD_BIT_IS_UNSET_POP_6_r21 956 -#define _GUARD_BIT_IS_UNSET_POP_6_r32 957 -#define _GUARD_BIT_IS_UNSET_POP_7_r00 958 -#define _GUARD_BIT_IS_UNSET_POP_7_r10 959 -#define _GUARD_BIT_IS_UNSET_POP_7_r21 960 -#define _GUARD_BIT_IS_UNSET_POP_7_r32 961 -#define _GUARD_CALLABLE_BUILTIN_CLASS_r00 962 -#define _GUARD_CALLABLE_BUILTIN_FAST_r00 963 -#define _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS_r00 964 -#define _GUARD_CALLABLE_BUILTIN_O_r00 965 -#define _GUARD_CALLABLE_ISINSTANCE_r03 966 -#define _GUARD_CALLABLE_ISINSTANCE_r13 967 -#define _GUARD_CALLABLE_ISINSTANCE_r23 968 -#define _GUARD_CALLABLE_ISINSTANCE_r33 969 -#define _GUARD_CALLABLE_LEN_r03 970 -#define _GUARD_CALLABLE_LEN_r13 971 -#define _GUARD_CALLABLE_LEN_r23 972 -#define _GUARD_CALLABLE_LEN_r33 973 -#define _GUARD_CALLABLE_LIST_APPEND_r03 974 -#define _GUARD_CALLABLE_LIST_APPEND_r13 975 -#define _GUARD_CALLABLE_LIST_APPEND_r23 976 -#define _GUARD_CALLABLE_LIST_APPEND_r33 977 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_r00 978 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00 979 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS_r00 980 -#define _GUARD_CALLABLE_METHOD_DESCRIPTOR_O_r00 981 -#define _GUARD_CALLABLE_STR_1_r03 982 -#define _GUARD_CALLABLE_STR_1_r13 983 -#define _GUARD_CALLABLE_STR_1_r23 984 -#define _GUARD_CALLABLE_STR_1_r33 985 -#define _GUARD_CALLABLE_TUPLE_1_r03 986 -#define _GUARD_CALLABLE_TUPLE_1_r13 987 -#define _GUARD_CALLABLE_TUPLE_1_r23 988 -#define _GUARD_CALLABLE_TUPLE_1_r33 989 -#define _GUARD_CALLABLE_TYPE_1_r03 990 -#define _GUARD_CALLABLE_TYPE_1_r13 991 -#define _GUARD_CALLABLE_TYPE_1_r23 992 -#define _GUARD_CALLABLE_TYPE_1_r33 993 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r00 994 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r11 995 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r22 996 -#define _GUARD_CODE_VERSION_RETURN_GENERATOR_r33 997 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r00 998 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r11 999 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r22 1000 -#define _GUARD_CODE_VERSION_RETURN_VALUE_r33 1001 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r00 1002 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r11 1003 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r22 1004 -#define _GUARD_CODE_VERSION_YIELD_VALUE_r33 1005 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r00 1006 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r11 1007 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r22 1008 -#define _GUARD_CODE_VERSION__PUSH_FRAME_r33 1009 -#define _GUARD_DORV_NO_DICT_r01 1010 -#define _GUARD_DORV_NO_DICT_r11 1011 -#define _GUARD_DORV_NO_DICT_r22 1012 -#define _GUARD_DORV_NO_DICT_r33 1013 -#define _GUARD_GLOBALS_VERSION_r00 1014 -#define _GUARD_GLOBALS_VERSION_r11 1015 -#define _GUARD_GLOBALS_VERSION_r22 1016 -#define _GUARD_GLOBALS_VERSION_r33 1017 -#define _GUARD_IP_RETURN_GENERATOR_r00 1018 -#define _GUARD_IP_RETURN_GENERATOR_r11 1019 -#define _GUARD_IP_RETURN_GENERATOR_r22 1020 -#define _GUARD_IP_RETURN_GENERATOR_r33 1021 -#define _GUARD_IP_RETURN_VALUE_r00 1022 -#define _GUARD_IP_RETURN_VALUE_r11 1023 -#define _GUARD_IP_RETURN_VALUE_r22 1024 -#define _GUARD_IP_RETURN_VALUE_r33 1025 -#define _GUARD_IP_YIELD_VALUE_r00 1026 -#define _GUARD_IP_YIELD_VALUE_r11 1027 -#define _GUARD_IP_YIELD_VALUE_r22 1028 -#define _GUARD_IP_YIELD_VALUE_r33 1029 -#define _GUARD_IP__PUSH_FRAME_r00 1030 -#define _GUARD_IP__PUSH_FRAME_r11 1031 -#define _GUARD_IP__PUSH_FRAME_r22 1032 -#define _GUARD_IP__PUSH_FRAME_r33 1033 -#define _GUARD_IS_FALSE_POP_r00 1034 -#define _GUARD_IS_FALSE_POP_r10 1035 -#define _GUARD_IS_FALSE_POP_r21 1036 -#define _GUARD_IS_FALSE_POP_r32 1037 -#define _GUARD_IS_NONE_POP_r00 1038 -#define _GUARD_IS_NONE_POP_r10 1039 -#define _GUARD_IS_NONE_POP_r21 1040 -#define _GUARD_IS_NONE_POP_r32 1041 -#define _GUARD_IS_NOT_NONE_POP_r10 1042 -#define _GUARD_IS_TRUE_POP_r00 1043 -#define _GUARD_IS_TRUE_POP_r10 1044 -#define _GUARD_IS_TRUE_POP_r21 1045 -#define _GUARD_IS_TRUE_POP_r32 1046 -#define _GUARD_ITERATOR_r01 1047 -#define _GUARD_ITERATOR_r11 1048 -#define _GUARD_ITERATOR_r22 1049 -#define _GUARD_ITERATOR_r33 1050 -#define _GUARD_ITER_VIRTUAL_r01 1051 -#define _GUARD_ITER_VIRTUAL_r11 1052 -#define _GUARD_ITER_VIRTUAL_r22 1053 -#define _GUARD_ITER_VIRTUAL_r33 1054 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r03 1055 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r13 1056 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r23 1057 -#define _GUARD_LOAD_SUPER_ATTR_METHOD_r33 1058 -#define _GUARD_NOS_COMPACT_ASCII_r02 1059 -#define _GUARD_NOS_COMPACT_ASCII_r12 1060 -#define _GUARD_NOS_COMPACT_ASCII_r22 1061 -#define _GUARD_NOS_COMPACT_ASCII_r33 1062 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r03 1063 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r13 1064 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r23 1065 -#define _GUARD_NOS_DICT_STORE_SUBSCRIPT_r33 1066 -#define _GUARD_NOS_DICT_SUBSCRIPT_r02 1067 -#define _GUARD_NOS_DICT_SUBSCRIPT_r12 1068 -#define _GUARD_NOS_DICT_SUBSCRIPT_r22 1069 -#define _GUARD_NOS_DICT_SUBSCRIPT_r33 1070 -#define _GUARD_NOS_FLOAT_r02 1071 -#define _GUARD_NOS_FLOAT_r12 1072 -#define _GUARD_NOS_FLOAT_r22 1073 -#define _GUARD_NOS_FLOAT_r33 1074 -#define _GUARD_NOS_INT_r02 1075 -#define _GUARD_NOS_INT_r12 1076 -#define _GUARD_NOS_INT_r22 1077 -#define _GUARD_NOS_INT_r33 1078 -#define _GUARD_NOS_ITER_VIRTUAL_r02 1079 -#define _GUARD_NOS_ITER_VIRTUAL_r12 1080 -#define _GUARD_NOS_ITER_VIRTUAL_r22 1081 -#define _GUARD_NOS_ITER_VIRTUAL_r33 1082 -#define _GUARD_NOS_LIST_r02 1083 -#define _GUARD_NOS_LIST_r12 1084 -#define _GUARD_NOS_LIST_r22 1085 -#define _GUARD_NOS_LIST_r33 1086 -#define _GUARD_NOS_NOT_NULL_r02 1087 -#define _GUARD_NOS_NOT_NULL_r12 1088 -#define _GUARD_NOS_NOT_NULL_r22 1089 -#define _GUARD_NOS_NOT_NULL_r33 1090 -#define _GUARD_NOS_NULL_r02 1091 -#define _GUARD_NOS_NULL_r12 1092 -#define _GUARD_NOS_NULL_r22 1093 -#define _GUARD_NOS_NULL_r33 1094 -#define _GUARD_NOS_OVERFLOWED_r02 1095 -#define _GUARD_NOS_OVERFLOWED_r12 1096 -#define _GUARD_NOS_OVERFLOWED_r22 1097 -#define _GUARD_NOS_OVERFLOWED_r33 1098 -#define _GUARD_NOS_TUPLE_r02 1099 -#define _GUARD_NOS_TUPLE_r12 1100 -#define _GUARD_NOS_TUPLE_r22 1101 -#define _GUARD_NOS_TUPLE_r33 1102 -#define _GUARD_NOS_TYPE_VERSION_r02 1103 -#define _GUARD_NOS_TYPE_VERSION_r12 1104 -#define _GUARD_NOS_TYPE_VERSION_r22 1105 -#define _GUARD_NOS_TYPE_VERSION_r33 1106 -#define _GUARD_NOS_UNICODE_r02 1107 -#define _GUARD_NOS_UNICODE_r12 1108 -#define _GUARD_NOS_UNICODE_r22 1109 -#define _GUARD_NOS_UNICODE_r33 1110 -#define _GUARD_NOT_EXHAUSTED_LIST_r02 1111 -#define _GUARD_NOT_EXHAUSTED_LIST_r12 1112 -#define _GUARD_NOT_EXHAUSTED_LIST_r22 1113 -#define _GUARD_NOT_EXHAUSTED_LIST_r33 1114 -#define _GUARD_NOT_EXHAUSTED_RANGE_r02 1115 -#define _GUARD_NOT_EXHAUSTED_RANGE_r12 1116 -#define _GUARD_NOT_EXHAUSTED_RANGE_r22 1117 -#define _GUARD_NOT_EXHAUSTED_RANGE_r33 1118 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 1119 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 1120 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 1121 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 1122 -#define _GUARD_THIRD_NULL_r03 1123 -#define _GUARD_THIRD_NULL_r13 1124 -#define _GUARD_THIRD_NULL_r23 1125 -#define _GUARD_THIRD_NULL_r33 1126 -#define _GUARD_TOS_ANY_DICT_r01 1127 -#define _GUARD_TOS_ANY_DICT_r11 1128 -#define _GUARD_TOS_ANY_DICT_r22 1129 -#define _GUARD_TOS_ANY_DICT_r33 1130 -#define _GUARD_TOS_ANY_SET_r01 1131 -#define _GUARD_TOS_ANY_SET_r11 1132 -#define _GUARD_TOS_ANY_SET_r22 1133 -#define _GUARD_TOS_ANY_SET_r33 1134 -#define _GUARD_TOS_DICT_r01 1135 -#define _GUARD_TOS_DICT_r11 1136 -#define _GUARD_TOS_DICT_r22 1137 -#define _GUARD_TOS_DICT_r33 1138 -#define _GUARD_TOS_FLOAT_r01 1139 -#define _GUARD_TOS_FLOAT_r11 1140 -#define _GUARD_TOS_FLOAT_r22 1141 -#define _GUARD_TOS_FLOAT_r33 1142 -#define _GUARD_TOS_FROZENDICT_r01 1143 -#define _GUARD_TOS_FROZENDICT_r11 1144 -#define _GUARD_TOS_FROZENDICT_r22 1145 -#define _GUARD_TOS_FROZENDICT_r33 1146 -#define _GUARD_TOS_FROZENSET_r01 1147 -#define _GUARD_TOS_FROZENSET_r11 1148 -#define _GUARD_TOS_FROZENSET_r22 1149 -#define _GUARD_TOS_FROZENSET_r33 1150 -#define _GUARD_TOS_INT_r01 1151 -#define _GUARD_TOS_INT_r11 1152 -#define _GUARD_TOS_INT_r22 1153 -#define _GUARD_TOS_INT_r33 1154 -#define _GUARD_TOS_IS_NONE_r01 1155 -#define _GUARD_TOS_IS_NONE_r11 1156 -#define _GUARD_TOS_IS_NONE_r22 1157 -#define _GUARD_TOS_IS_NONE_r33 1158 -#define _GUARD_TOS_LIST_r01 1159 -#define _GUARD_TOS_LIST_r11 1160 -#define _GUARD_TOS_LIST_r22 1161 -#define _GUARD_TOS_LIST_r33 1162 -#define _GUARD_TOS_NOT_NULL_r01 1163 -#define _GUARD_TOS_NOT_NULL_r11 1164 -#define _GUARD_TOS_NOT_NULL_r22 1165 -#define _GUARD_TOS_NOT_NULL_r33 1166 -#define _GUARD_TOS_OVERFLOWED_r01 1167 -#define _GUARD_TOS_OVERFLOWED_r11 1168 -#define _GUARD_TOS_OVERFLOWED_r22 1169 -#define _GUARD_TOS_OVERFLOWED_r33 1170 -#define _GUARD_TOS_SET_r01 1171 -#define _GUARD_TOS_SET_r11 1172 -#define _GUARD_TOS_SET_r22 1173 -#define _GUARD_TOS_SET_r33 1174 -#define _GUARD_TOS_SLICE_r01 1175 -#define _GUARD_TOS_SLICE_r11 1176 -#define _GUARD_TOS_SLICE_r22 1177 -#define _GUARD_TOS_SLICE_r33 1178 -#define _GUARD_TOS_TUPLE_r01 1179 -#define _GUARD_TOS_TUPLE_r11 1180 -#define _GUARD_TOS_TUPLE_r22 1181 -#define _GUARD_TOS_TUPLE_r33 1182 -#define _GUARD_TOS_UNICODE_r01 1183 -#define _GUARD_TOS_UNICODE_r11 1184 -#define _GUARD_TOS_UNICODE_r22 1185 -#define _GUARD_TOS_UNICODE_r33 1186 -#define _GUARD_TYPE_r01 1187 -#define _GUARD_TYPE_r11 1188 -#define _GUARD_TYPE_r22 1189 -#define _GUARD_TYPE_r33 1190 -#define _GUARD_TYPE_ITER_r02 1191 -#define _GUARD_TYPE_ITER_r12 1192 -#define _GUARD_TYPE_ITER_r22 1193 -#define _GUARD_TYPE_ITER_r33 1194 -#define _GUARD_TYPE_VERSION_r01 1195 -#define _GUARD_TYPE_VERSION_r11 1196 -#define _GUARD_TYPE_VERSION_r22 1197 -#define _GUARD_TYPE_VERSION_r33 1198 -#define _GUARD_TYPE_VERSION_LOCKED_r01 1199 -#define _GUARD_TYPE_VERSION_LOCKED_r11 1200 -#define _GUARD_TYPE_VERSION_LOCKED_r22 1201 -#define _GUARD_TYPE_VERSION_LOCKED_r33 1202 -#define _HANDLE_PENDING_AND_DEOPT_r00 1203 -#define _HANDLE_PENDING_AND_DEOPT_r10 1204 -#define _HANDLE_PENDING_AND_DEOPT_r20 1205 -#define _HANDLE_PENDING_AND_DEOPT_r30 1206 -#define _IMPORT_FROM_r12 1207 -#define _IMPORT_NAME_r21 1208 -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1209 -#define _INIT_CALL_PY_EXACT_ARGS_r01 1210 -#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1211 -#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1212 -#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1213 -#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1214 -#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1215 -#define _INSERT_NULL_r10 1216 -#define _INSTRUMENTED_FOR_ITER_r23 1217 -#define _INSTRUMENTED_INSTRUCTION_r00 1218 -#define _INSTRUMENTED_JUMP_FORWARD_r00 1219 -#define _INSTRUMENTED_JUMP_FORWARD_r11 1220 -#define _INSTRUMENTED_JUMP_FORWARD_r22 1221 -#define _INSTRUMENTED_JUMP_FORWARD_r33 1222 -#define _INSTRUMENTED_LINE_r00 1223 -#define _INSTRUMENTED_NOT_TAKEN_r00 1224 -#define _INSTRUMENTED_NOT_TAKEN_r11 1225 -#define _INSTRUMENTED_NOT_TAKEN_r22 1226 -#define _INSTRUMENTED_NOT_TAKEN_r33 1227 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1228 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1229 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1230 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1231 -#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1232 -#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1233 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1234 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1235 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1236 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1237 -#define _IS_NONE_r11 1238 -#define _IS_OP_r03 1239 -#define _IS_OP_r13 1240 -#define _IS_OP_r23 1241 -#define _ITER_CHECK_LIST_r02 1242 -#define _ITER_CHECK_LIST_r12 1243 -#define _ITER_CHECK_LIST_r22 1244 -#define _ITER_CHECK_LIST_r33 1245 -#define _ITER_CHECK_RANGE_r02 1246 -#define _ITER_CHECK_RANGE_r12 1247 -#define _ITER_CHECK_RANGE_r22 1248 -#define _ITER_CHECK_RANGE_r33 1249 -#define _ITER_CHECK_TUPLE_r02 1250 -#define _ITER_CHECK_TUPLE_r12 1251 -#define _ITER_CHECK_TUPLE_r22 1252 -#define _ITER_CHECK_TUPLE_r33 1253 -#define _ITER_JUMP_LIST_r02 1254 -#define _ITER_JUMP_LIST_r12 1255 -#define _ITER_JUMP_LIST_r22 1256 -#define _ITER_JUMP_LIST_r33 1257 -#define _ITER_JUMP_RANGE_r02 1258 -#define _ITER_JUMP_RANGE_r12 1259 -#define _ITER_JUMP_RANGE_r22 1260 -#define _ITER_JUMP_RANGE_r33 1261 -#define _ITER_JUMP_TUPLE_r02 1262 -#define _ITER_JUMP_TUPLE_r12 1263 -#define _ITER_JUMP_TUPLE_r22 1264 -#define _ITER_JUMP_TUPLE_r33 1265 -#define _ITER_NEXT_INLINE_r23 1266 -#define _ITER_NEXT_LIST_r23 1267 -#define _ITER_NEXT_LIST_TIER_TWO_r23 1268 -#define _ITER_NEXT_RANGE_r03 1269 -#define _ITER_NEXT_RANGE_r13 1270 -#define _ITER_NEXT_RANGE_r23 1271 -#define _ITER_NEXT_TUPLE_r03 1272 -#define _ITER_NEXT_TUPLE_r13 1273 -#define _ITER_NEXT_TUPLE_r23 1274 -#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1275 -#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1276 -#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1277 -#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1278 -#define _JUMP_TO_TOP_r00 1279 -#define _LIST_APPEND_r10 1280 -#define _LIST_EXTEND_r11 1281 -#define _LOAD_ATTR_r10 1282 -#define _LOAD_ATTR_CLASS_r11 1283 -#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME_r11 1284 -#define _LOAD_ATTR_INSTANCE_VALUE_r02 1285 -#define _LOAD_ATTR_INSTANCE_VALUE_r12 1286 -#define _LOAD_ATTR_INSTANCE_VALUE_r23 1287 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1288 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1289 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1290 -#define _LOAD_ATTR_METHOD_NO_DICT_r02 1291 -#define _LOAD_ATTR_METHOD_NO_DICT_r12 1292 -#define _LOAD_ATTR_METHOD_NO_DICT_r23 1293 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1294 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1295 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1296 -#define _LOAD_ATTR_MODULE_r12 1297 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1298 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1299 -#define _LOAD_ATTR_PROPERTY_FRAME_r01 1300 -#define _LOAD_ATTR_PROPERTY_FRAME_r11 1301 -#define _LOAD_ATTR_PROPERTY_FRAME_r22 1302 -#define _LOAD_ATTR_PROPERTY_FRAME_r33 1303 -#define _LOAD_ATTR_SLOT_r02 1304 -#define _LOAD_ATTR_SLOT_r12 1305 -#define _LOAD_ATTR_SLOT_r23 1306 -#define _LOAD_ATTR_WITH_HINT_r12 1307 -#define _LOAD_BUILD_CLASS_r01 1308 -#define _LOAD_BYTECODE_r00 1309 -#define _LOAD_COMMON_CONSTANT_r01 1310 -#define _LOAD_COMMON_CONSTANT_r12 1311 -#define _LOAD_COMMON_CONSTANT_r23 1312 -#define _LOAD_CONST_r01 1313 -#define _LOAD_CONST_r12 1314 -#define _LOAD_CONST_r23 1315 -#define _LOAD_CONST_INLINE_r01 1316 -#define _LOAD_CONST_INLINE_r12 1317 -#define _LOAD_CONST_INLINE_r23 1318 -#define _LOAD_CONST_INLINE_BORROW_r01 1319 -#define _LOAD_CONST_INLINE_BORROW_r12 1320 -#define _LOAD_CONST_INLINE_BORROW_r23 1321 -#define _LOAD_DEREF_r01 1322 -#define _LOAD_FAST_r01 1323 -#define _LOAD_FAST_r12 1324 -#define _LOAD_FAST_r23 1325 -#define _LOAD_FAST_0_r01 1326 -#define _LOAD_FAST_0_r12 1327 -#define _LOAD_FAST_0_r23 1328 -#define _LOAD_FAST_1_r01 1329 -#define _LOAD_FAST_1_r12 1330 -#define _LOAD_FAST_1_r23 1331 -#define _LOAD_FAST_2_r01 1332 -#define _LOAD_FAST_2_r12 1333 -#define _LOAD_FAST_2_r23 1334 -#define _LOAD_FAST_3_r01 1335 -#define _LOAD_FAST_3_r12 1336 -#define _LOAD_FAST_3_r23 1337 -#define _LOAD_FAST_4_r01 1338 -#define _LOAD_FAST_4_r12 1339 -#define _LOAD_FAST_4_r23 1340 -#define _LOAD_FAST_5_r01 1341 -#define _LOAD_FAST_5_r12 1342 -#define _LOAD_FAST_5_r23 1343 -#define _LOAD_FAST_6_r01 1344 -#define _LOAD_FAST_6_r12 1345 -#define _LOAD_FAST_6_r23 1346 -#define _LOAD_FAST_7_r01 1347 -#define _LOAD_FAST_7_r12 1348 -#define _LOAD_FAST_7_r23 1349 -#define _LOAD_FAST_AND_CLEAR_r01 1350 -#define _LOAD_FAST_AND_CLEAR_r12 1351 -#define _LOAD_FAST_AND_CLEAR_r23 1352 -#define _LOAD_FAST_BORROW_r01 1353 -#define _LOAD_FAST_BORROW_r12 1354 -#define _LOAD_FAST_BORROW_r23 1355 -#define _LOAD_FAST_BORROW_0_r01 1356 -#define _LOAD_FAST_BORROW_0_r12 1357 -#define _LOAD_FAST_BORROW_0_r23 1358 -#define _LOAD_FAST_BORROW_1_r01 1359 -#define _LOAD_FAST_BORROW_1_r12 1360 -#define _LOAD_FAST_BORROW_1_r23 1361 -#define _LOAD_FAST_BORROW_2_r01 1362 -#define _LOAD_FAST_BORROW_2_r12 1363 -#define _LOAD_FAST_BORROW_2_r23 1364 -#define _LOAD_FAST_BORROW_3_r01 1365 -#define _LOAD_FAST_BORROW_3_r12 1366 -#define _LOAD_FAST_BORROW_3_r23 1367 -#define _LOAD_FAST_BORROW_4_r01 1368 -#define _LOAD_FAST_BORROW_4_r12 1369 -#define _LOAD_FAST_BORROW_4_r23 1370 -#define _LOAD_FAST_BORROW_5_r01 1371 -#define _LOAD_FAST_BORROW_5_r12 1372 -#define _LOAD_FAST_BORROW_5_r23 1373 -#define _LOAD_FAST_BORROW_6_r01 1374 -#define _LOAD_FAST_BORROW_6_r12 1375 -#define _LOAD_FAST_BORROW_6_r23 1376 -#define _LOAD_FAST_BORROW_7_r01 1377 -#define _LOAD_FAST_BORROW_7_r12 1378 -#define _LOAD_FAST_BORROW_7_r23 1379 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1380 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1381 -#define _LOAD_FAST_CHECK_r01 1382 -#define _LOAD_FAST_CHECK_r12 1383 -#define _LOAD_FAST_CHECK_r23 1384 -#define _LOAD_FAST_LOAD_FAST_r02 1385 -#define _LOAD_FAST_LOAD_FAST_r13 1386 -#define _LOAD_FROM_DICT_OR_DEREF_r11 1387 -#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1388 -#define _LOAD_GLOBAL_r00 1389 -#define _LOAD_GLOBAL_BUILTINS_r01 1390 -#define _LOAD_GLOBAL_MODULE_r01 1391 -#define _LOAD_LOCALS_r01 1392 -#define _LOAD_LOCALS_r12 1393 -#define _LOAD_LOCALS_r23 1394 -#define _LOAD_NAME_r01 1395 -#define _LOAD_SMALL_INT_r01 1396 -#define _LOAD_SMALL_INT_r12 1397 -#define _LOAD_SMALL_INT_r23 1398 -#define _LOAD_SMALL_INT_0_r01 1399 -#define _LOAD_SMALL_INT_0_r12 1400 -#define _LOAD_SMALL_INT_0_r23 1401 -#define _LOAD_SMALL_INT_1_r01 1402 -#define _LOAD_SMALL_INT_1_r12 1403 -#define _LOAD_SMALL_INT_1_r23 1404 -#define _LOAD_SMALL_INT_2_r01 1405 -#define _LOAD_SMALL_INT_2_r12 1406 -#define _LOAD_SMALL_INT_2_r23 1407 -#define _LOAD_SMALL_INT_3_r01 1408 -#define _LOAD_SMALL_INT_3_r12 1409 -#define _LOAD_SMALL_INT_3_r23 1410 -#define _LOAD_SPECIAL_r00 1411 -#define _LOAD_SUPER_ATTR_ATTR_r31 1412 -#define _LOAD_SUPER_ATTR_METHOD_r32 1413 -#define _LOCK_OBJECT_r01 1414 -#define _LOCK_OBJECT_r11 1415 -#define _LOCK_OBJECT_r22 1416 -#define _LOCK_OBJECT_r33 1417 -#define _MAKE_CALLARGS_A_TUPLE_r33 1418 -#define _MAKE_CELL_r00 1419 -#define _MAKE_FUNCTION_r12 1420 -#define _MAKE_HEAP_SAFE_r01 1421 -#define _MAKE_HEAP_SAFE_r11 1422 -#define _MAKE_HEAP_SAFE_r22 1423 -#define _MAKE_HEAP_SAFE_r33 1424 -#define _MAKE_WARM_r00 1425 -#define _MAKE_WARM_r11 1426 -#define _MAKE_WARM_r22 1427 -#define _MAKE_WARM_r33 1428 -#define _MAP_ADD_r20 1429 -#define _MATCH_CLASS_r33 1430 -#define _MATCH_KEYS_r23 1431 -#define _MATCH_MAPPING_r02 1432 -#define _MATCH_MAPPING_r12 1433 -#define _MATCH_MAPPING_r23 1434 -#define _MATCH_SEQUENCE_r02 1435 -#define _MATCH_SEQUENCE_r12 1436 -#define _MATCH_SEQUENCE_r23 1437 -#define _MAYBE_EXPAND_METHOD_r00 1438 -#define _MAYBE_EXPAND_METHOD_KW_r11 1439 -#define _MONITOR_CALL_r00 1440 -#define _MONITOR_CALL_KW_r11 1441 -#define _MONITOR_JUMP_BACKWARD_r00 1442 -#define _MONITOR_JUMP_BACKWARD_r11 1443 -#define _MONITOR_JUMP_BACKWARD_r22 1444 -#define _MONITOR_JUMP_BACKWARD_r33 1445 -#define _MONITOR_RESUME_r00 1446 -#define _NOP_r00 1447 -#define _NOP_r11 1448 -#define _NOP_r22 1449 -#define _NOP_r33 1450 -#define _POP_EXCEPT_r10 1451 -#define _POP_ITER_r20 1452 -#define _POP_JUMP_IF_FALSE_r00 1453 -#define _POP_JUMP_IF_FALSE_r10 1454 -#define _POP_JUMP_IF_FALSE_r21 1455 -#define _POP_JUMP_IF_FALSE_r32 1456 -#define _POP_JUMP_IF_TRUE_r00 1457 -#define _POP_JUMP_IF_TRUE_r10 1458 -#define _POP_JUMP_IF_TRUE_r21 1459 -#define _POP_JUMP_IF_TRUE_r32 1460 -#define _POP_TOP_r10 1461 -#define _POP_TOP_FLOAT_r00 1462 -#define _POP_TOP_FLOAT_r10 1463 -#define _POP_TOP_FLOAT_r21 1464 -#define _POP_TOP_FLOAT_r32 1465 -#define _POP_TOP_INT_r00 1466 -#define _POP_TOP_INT_r10 1467 -#define _POP_TOP_INT_r21 1468 -#define _POP_TOP_INT_r32 1469 -#define _POP_TOP_NOP_r00 1470 -#define _POP_TOP_NOP_r10 1471 -#define _POP_TOP_NOP_r21 1472 -#define _POP_TOP_NOP_r32 1473 -#define _POP_TOP_OPARG_r00 1474 -#define _POP_TOP_UNICODE_r00 1475 -#define _POP_TOP_UNICODE_r10 1476 -#define _POP_TOP_UNICODE_r21 1477 -#define _POP_TOP_UNICODE_r32 1478 -#define _PUSH_EXC_INFO_r02 1479 -#define _PUSH_EXC_INFO_r12 1480 -#define _PUSH_EXC_INFO_r23 1481 -#define _PUSH_FRAME_r10 1482 -#define _PUSH_NULL_r01 1483 -#define _PUSH_NULL_r12 1484 -#define _PUSH_NULL_r23 1485 -#define _PUSH_NULL_CONDITIONAL_r00 1486 -#define _PUSH_TAGGED_ZERO_r01 1487 -#define _PUSH_TAGGED_ZERO_r12 1488 -#define _PUSH_TAGGED_ZERO_r23 1489 -#define _PY_FRAME_EX_r31 1490 -#define _PY_FRAME_GENERAL_r01 1491 -#define _PY_FRAME_KW_r11 1492 -#define _REPLACE_WITH_TRUE_r02 1493 -#define _REPLACE_WITH_TRUE_r12 1494 -#define _REPLACE_WITH_TRUE_r23 1495 -#define _RESUME_CHECK_r00 1496 -#define _RESUME_CHECK_r11 1497 -#define _RESUME_CHECK_r22 1498 -#define _RESUME_CHECK_r33 1499 -#define _RETURN_GENERATOR_r01 1500 -#define _RETURN_VALUE_r11 1501 -#define _RROT_3_r03 1502 -#define _RROT_3_r13 1503 -#define _RROT_3_r23 1504 -#define _RROT_3_r33 1505 -#define _SAVE_RETURN_OFFSET_r00 1506 -#define _SAVE_RETURN_OFFSET_r11 1507 -#define _SAVE_RETURN_OFFSET_r22 1508 -#define _SAVE_RETURN_OFFSET_r33 1509 -#define _SEND_ASYNC_GEN_r33 1510 -#define _SEND_ASYNC_GEN_TIER_TWO_r33 1511 -#define _SEND_GEN_FRAME_r33 1512 -#define _SEND_VIRTUAL_r33 1513 -#define _SEND_VIRTUAL_TIER_TWO_r03 1514 -#define _SEND_VIRTUAL_TIER_TWO_r13 1515 -#define _SEND_VIRTUAL_TIER_TWO_r23 1516 -#define _SEND_VIRTUAL_TIER_TWO_r33 1517 -#define _SETUP_ANNOTATIONS_r00 1518 -#define _SET_ADD_r10 1519 -#define _SET_FUNCTION_ATTRIBUTE_r01 1520 -#define _SET_FUNCTION_ATTRIBUTE_r11 1521 -#define _SET_FUNCTION_ATTRIBUTE_r21 1522 -#define _SET_FUNCTION_ATTRIBUTE_r32 1523 -#define _SET_IP_r00 1524 -#define _SET_IP_r11 1525 -#define _SET_IP_r22 1526 -#define _SET_IP_r33 1527 -#define _SET_UPDATE_r11 1528 -#define _SPILL_OR_RELOAD_r01 1529 -#define _SPILL_OR_RELOAD_r02 1530 -#define _SPILL_OR_RELOAD_r03 1531 -#define _SPILL_OR_RELOAD_r10 1532 -#define _SPILL_OR_RELOAD_r12 1533 -#define _SPILL_OR_RELOAD_r13 1534 -#define _SPILL_OR_RELOAD_r20 1535 -#define _SPILL_OR_RELOAD_r21 1536 -#define _SPILL_OR_RELOAD_r23 1537 -#define _SPILL_OR_RELOAD_r30 1538 -#define _SPILL_OR_RELOAD_r31 1539 -#define _SPILL_OR_RELOAD_r32 1540 -#define _START_EXECUTOR_r00 1541 -#define _STORE_ATTR_r20 1542 -#define _STORE_ATTR_INSTANCE_VALUE_r21 1543 -#define _STORE_ATTR_SLOT_r21 1544 -#define _STORE_ATTR_WITH_HINT_r21 1545 -#define _STORE_DEREF_r10 1546 -#define _STORE_FAST_LOAD_FAST_r11 1547 -#define _STORE_FAST_STORE_FAST_r20 1548 -#define _STORE_GLOBAL_r10 1549 -#define _STORE_NAME_r10 1550 -#define _STORE_SLICE_r30 1551 -#define _STORE_SUBSCR_r30 1552 -#define _STORE_SUBSCR_DICT_r31 1553 -#define _STORE_SUBSCR_DICT_KNOWN_HASH_r31 1554 -#define _STORE_SUBSCR_LIST_INT_r32 1555 -#define _SWAP_r11 1556 -#define _SWAP_2_r02 1557 -#define _SWAP_2_r12 1558 -#define _SWAP_2_r22 1559 -#define _SWAP_2_r33 1560 -#define _SWAP_3_r03 1561 -#define _SWAP_3_r13 1562 -#define _SWAP_3_r23 1563 -#define _SWAP_3_r33 1564 -#define _SWAP_FAST_r01 1565 -#define _SWAP_FAST_r11 1566 -#define _SWAP_FAST_r22 1567 -#define _SWAP_FAST_r33 1568 -#define _SWAP_FAST_0_r01 1569 -#define _SWAP_FAST_0_r11 1570 -#define _SWAP_FAST_0_r22 1571 -#define _SWAP_FAST_0_r33 1572 -#define _SWAP_FAST_1_r01 1573 -#define _SWAP_FAST_1_r11 1574 -#define _SWAP_FAST_1_r22 1575 -#define _SWAP_FAST_1_r33 1576 -#define _SWAP_FAST_2_r01 1577 -#define _SWAP_FAST_2_r11 1578 -#define _SWAP_FAST_2_r22 1579 -#define _SWAP_FAST_2_r33 1580 -#define _SWAP_FAST_3_r01 1581 -#define _SWAP_FAST_3_r11 1582 -#define _SWAP_FAST_3_r22 1583 -#define _SWAP_FAST_3_r33 1584 -#define _SWAP_FAST_4_r01 1585 -#define _SWAP_FAST_4_r11 1586 -#define _SWAP_FAST_4_r22 1587 -#define _SWAP_FAST_4_r33 1588 -#define _SWAP_FAST_5_r01 1589 -#define _SWAP_FAST_5_r11 1590 -#define _SWAP_FAST_5_r22 1591 -#define _SWAP_FAST_5_r33 1592 -#define _SWAP_FAST_6_r01 1593 -#define _SWAP_FAST_6_r11 1594 -#define _SWAP_FAST_6_r22 1595 -#define _SWAP_FAST_6_r33 1596 -#define _SWAP_FAST_7_r01 1597 -#define _SWAP_FAST_7_r11 1598 -#define _SWAP_FAST_7_r22 1599 -#define _SWAP_FAST_7_r33 1600 -#define _TIER2_RESUME_CHECK_r00 1601 -#define _TIER2_RESUME_CHECK_r11 1602 -#define _TIER2_RESUME_CHECK_r22 1603 -#define _TIER2_RESUME_CHECK_r33 1604 -#define _TO_BOOL_r11 1605 -#define _TO_BOOL_BOOL_r01 1606 -#define _TO_BOOL_BOOL_r11 1607 -#define _TO_BOOL_BOOL_r22 1608 -#define _TO_BOOL_BOOL_r33 1609 -#define _TO_BOOL_INT_r02 1610 -#define _TO_BOOL_INT_r12 1611 -#define _TO_BOOL_INT_r23 1612 -#define _TO_BOOL_LIST_r02 1613 -#define _TO_BOOL_LIST_r12 1614 -#define _TO_BOOL_LIST_r23 1615 -#define _TO_BOOL_NONE_r01 1616 -#define _TO_BOOL_NONE_r11 1617 -#define _TO_BOOL_NONE_r22 1618 -#define _TO_BOOL_NONE_r33 1619 -#define _TO_BOOL_STR_r02 1620 -#define _TO_BOOL_STR_r12 1621 -#define _TO_BOOL_STR_r23 1622 -#define _TRACE_RECORD_r00 1623 -#define _UNARY_INVERT_r12 1624 -#define _UNARY_NEGATIVE_r12 1625 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r02 1626 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r12 1627 -#define _UNARY_NEGATIVE_FLOAT_INPLACE_r23 1628 -#define _UNARY_NOT_r01 1629 -#define _UNARY_NOT_r11 1630 -#define _UNARY_NOT_r22 1631 -#define _UNARY_NOT_r33 1632 -#define _UNPACK_EX_r10 1633 -#define _UNPACK_SEQUENCE_r10 1634 -#define _UNPACK_SEQUENCE_LIST_r10 1635 -#define _UNPACK_SEQUENCE_TUPLE_r10 1636 -#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1637 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r03 1638 -#define _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r13 1639 -#define _UNPACK_SEQUENCE_UNIQUE_TUPLE_r10 1640 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r02 1641 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r12 1642 -#define _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r23 1643 -#define _WITH_EXCEPT_START_r33 1644 -#define _YIELD_VALUE_r11 1645 + +enum { + _ALLOCATE_OBJECT_r00 = MAX_UOP_ID + 1, + _BINARY_OP_r23, + _BINARY_OP_ADD_FLOAT_r03, + _BINARY_OP_ADD_FLOAT_r13, + _BINARY_OP_ADD_FLOAT_r23, + _BINARY_OP_ADD_FLOAT_INPLACE_r03, + _BINARY_OP_ADD_FLOAT_INPLACE_r13, + _BINARY_OP_ADD_FLOAT_INPLACE_r23, + _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r03, + _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r13, + _BINARY_OP_ADD_FLOAT_INPLACE_RIGHT_r23, + _BINARY_OP_ADD_INT_r03, + _BINARY_OP_ADD_INT_r13, + _BINARY_OP_ADD_INT_r23, + _BINARY_OP_ADD_INT_INPLACE_r03, + _BINARY_OP_ADD_INT_INPLACE_r13, + _BINARY_OP_ADD_INT_INPLACE_r23, + _BINARY_OP_ADD_INT_INPLACE_RIGHT_r03, + _BINARY_OP_ADD_INT_INPLACE_RIGHT_r13, + _BINARY_OP_ADD_INT_INPLACE_RIGHT_r23, + _BINARY_OP_ADD_UNICODE_r03, + _BINARY_OP_ADD_UNICODE_r13, + _BINARY_OP_ADD_UNICODE_r23, + _BINARY_OP_EXTEND_r23, + _BINARY_OP_INPLACE_ADD_UNICODE_r21, + _BINARY_OP_MULTIPLY_FLOAT_r03, + _BINARY_OP_MULTIPLY_FLOAT_r13, + _BINARY_OP_MULTIPLY_FLOAT_r23, + _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r03, + _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r13, + _BINARY_OP_MULTIPLY_FLOAT_INPLACE_r23, + _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r03, + _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r13, + _BINARY_OP_MULTIPLY_FLOAT_INPLACE_RIGHT_r23, + _BINARY_OP_MULTIPLY_INT_r03, + _BINARY_OP_MULTIPLY_INT_r13, + _BINARY_OP_MULTIPLY_INT_r23, + _BINARY_OP_MULTIPLY_INT_INPLACE_r03, + _BINARY_OP_MULTIPLY_INT_INPLACE_r13, + _BINARY_OP_MULTIPLY_INT_INPLACE_r23, + _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r03, + _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r13, + _BINARY_OP_MULTIPLY_INT_INPLACE_RIGHT_r23, + _BINARY_OP_SUBSCR_CHECK_FUNC_r23, + _BINARY_OP_SUBSCR_DICT_r23, + _BINARY_OP_SUBSCR_DICT_KNOWN_HASH_r23, + _BINARY_OP_SUBSCR_INIT_CALL_r01, + _BINARY_OP_SUBSCR_INIT_CALL_r11, + _BINARY_OP_SUBSCR_INIT_CALL_r21, + _BINARY_OP_SUBSCR_INIT_CALL_r31, + _BINARY_OP_SUBSCR_LIST_INT_r23, + _BINARY_OP_SUBSCR_LIST_SLICE_r23, + _BINARY_OP_SUBSCR_STR_INT_r23, + _BINARY_OP_SUBSCR_TUPLE_INT_r03, + _BINARY_OP_SUBSCR_TUPLE_INT_r13, + _BINARY_OP_SUBSCR_TUPLE_INT_r23, + _BINARY_OP_SUBSCR_USTR_INT_r23, + _BINARY_OP_SUBTRACT_FLOAT_r03, + _BINARY_OP_SUBTRACT_FLOAT_r13, + _BINARY_OP_SUBTRACT_FLOAT_r23, + _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r03, + _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r13, + _BINARY_OP_SUBTRACT_FLOAT_INPLACE_r23, + _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r03, + _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r13, + _BINARY_OP_SUBTRACT_FLOAT_INPLACE_RIGHT_r23, + _BINARY_OP_SUBTRACT_INT_r03, + _BINARY_OP_SUBTRACT_INT_r13, + _BINARY_OP_SUBTRACT_INT_r23, + _BINARY_OP_SUBTRACT_INT_INPLACE_r03, + _BINARY_OP_SUBTRACT_INT_INPLACE_r13, + _BINARY_OP_SUBTRACT_INT_INPLACE_r23, + _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r03, + _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r13, + _BINARY_OP_SUBTRACT_INT_INPLACE_RIGHT_r23, + _BINARY_OP_TRUEDIV_FLOAT_r23, + _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r03, + _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r13, + _BINARY_OP_TRUEDIV_FLOAT_INPLACE_r23, + _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r03, + _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r13, + _BINARY_OP_TRUEDIV_FLOAT_INPLACE_RIGHT_r23, + _BINARY_SLICE_r31, + _BUILD_INTERPOLATION_r01, + _BUILD_LIST_r01, + _BUILD_MAP_r01, + _BUILD_SET_r01, + _BUILD_SLICE_r01, + _BUILD_STRING_r01, + _BUILD_TEMPLATE_r21, + _BUILD_TUPLE_r01, + _CALL_BUILTIN_CLASS_r00, + _CALL_BUILTIN_FAST_r00, + _CALL_BUILTIN_FAST_WITH_KEYWORDS_r00, + _CALL_BUILTIN_O_r03, + _CALL_FUNCTION_EX_NON_PY_GENERAL_r31, + _CALL_INTRINSIC_1_r12, + _CALL_INTRINSIC_2_r23, + _CALL_ISINSTANCE_r31, + _CALL_KW_NON_PY_r11, + _CALL_LEN_r33, + _CALL_LIST_APPEND_r03, + _CALL_LIST_APPEND_r13, + _CALL_LIST_APPEND_r23, + _CALL_LIST_APPEND_r33, + _CALL_METHOD_DESCRIPTOR_FAST_r00, + _CALL_METHOD_DESCRIPTOR_FAST_INLINE_r00, + _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00, + _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE_r00, + _CALL_METHOD_DESCRIPTOR_NOARGS_r03, + _CALL_METHOD_DESCRIPTOR_NOARGS_INLINE_r03, + _CALL_METHOD_DESCRIPTOR_O_r03, + _CALL_METHOD_DESCRIPTOR_O_INLINE_r03, + _CALL_NON_PY_GENERAL_r01, + _CALL_STR_1_r32, + _CALL_TUPLE_1_r32, + _CALL_TYPE_1_r02, + _CALL_TYPE_1_r12, + _CALL_TYPE_1_r22, + _CALL_TYPE_1_r32, + _CHECK_ATTR_CLASS_r01, + _CHECK_ATTR_CLASS_r11, + _CHECK_ATTR_CLASS_r22, + _CHECK_ATTR_CLASS_r33, + _CHECK_ATTR_METHOD_LAZY_DICT_r01, + _CHECK_ATTR_METHOD_LAZY_DICT_r11, + _CHECK_ATTR_METHOD_LAZY_DICT_r22, + _CHECK_ATTR_METHOD_LAZY_DICT_r33, + _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00, + _CHECK_EG_MATCH_r22, + _CHECK_EXC_MATCH_r22, + _CHECK_FUNCTION_EXACT_ARGS_r00, + _CHECK_FUNCTION_VERSION_r00, + _CHECK_FUNCTION_VERSION_INLINE_r00, + _CHECK_FUNCTION_VERSION_INLINE_r11, + _CHECK_FUNCTION_VERSION_INLINE_r22, + _CHECK_FUNCTION_VERSION_INLINE_r33, + _CHECK_FUNCTION_VERSION_KW_r11, + _CHECK_IS_NOT_PY_CALLABLE_r00, + _CHECK_IS_NOT_PY_CALLABLE_EX_r03, + _CHECK_IS_NOT_PY_CALLABLE_EX_r13, + _CHECK_IS_NOT_PY_CALLABLE_EX_r23, + _CHECK_IS_NOT_PY_CALLABLE_EX_r33, + _CHECK_IS_NOT_PY_CALLABLE_KW_r11, + _CHECK_IS_PY_CALLABLE_EX_r03, + _CHECK_IS_PY_CALLABLE_EX_r13, + _CHECK_IS_PY_CALLABLE_EX_r23, + _CHECK_IS_PY_CALLABLE_EX_r33, + _CHECK_MANAGED_OBJECT_HAS_VALUES_r01, + _CHECK_MANAGED_OBJECT_HAS_VALUES_r11, + _CHECK_MANAGED_OBJECT_HAS_VALUES_r22, + _CHECK_MANAGED_OBJECT_HAS_VALUES_r33, + _CHECK_METHOD_VERSION_r00, + _CHECK_METHOD_VERSION_KW_r11, + _CHECK_OBJECT_r00, + _CHECK_PEP_523_r00, + _CHECK_PEP_523_r11, + _CHECK_PEP_523_r22, + _CHECK_PEP_523_r33, + _CHECK_PERIODIC_r00, + _CHECK_PERIODIC_AT_END_r00, + _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00, + _CHECK_RECURSION_LIMIT_r00, + _CHECK_RECURSION_LIMIT_r11, + _CHECK_RECURSION_LIMIT_r22, + _CHECK_RECURSION_LIMIT_r33, + _CHECK_RECURSION_REMAINING_r00, + _CHECK_RECURSION_REMAINING_r11, + _CHECK_RECURSION_REMAINING_r22, + _CHECK_RECURSION_REMAINING_r33, + _CHECK_STACK_SPACE_r00, + _CHECK_STACK_SPACE_OPERAND_r00, + _CHECK_STACK_SPACE_OPERAND_r11, + _CHECK_STACK_SPACE_OPERAND_r22, + _CHECK_STACK_SPACE_OPERAND_r33, + _CHECK_VALIDITY_r00, + _CHECK_VALIDITY_r11, + _CHECK_VALIDITY_r22, + _CHECK_VALIDITY_r33, + _COLD_DYNAMIC_EXIT_r00, + _COLD_EXIT_r00, + _COMPARE_OP_r21, + _COMPARE_OP_FLOAT_r03, + _COMPARE_OP_FLOAT_r13, + _COMPARE_OP_FLOAT_r23, + _COMPARE_OP_INT_r23, + _COMPARE_OP_STR_r23, + _CONTAINS_OP_r23, + _CONTAINS_OP_DICT_r23, + _CONTAINS_OP_SET_r23, + _CONVERT_VALUE_r11, + _COPY_r01, + _COPY_1_r02, + _COPY_1_r12, + _COPY_1_r23, + _COPY_2_r03, + _COPY_2_r13, + _COPY_2_r23, + _COPY_3_r03, + _COPY_3_r13, + _COPY_3_r23, + _COPY_3_r33, + _COPY_FREE_VARS_r00, + _COPY_FREE_VARS_r11, + _COPY_FREE_VARS_r22, + _COPY_FREE_VARS_r33, + _CREATE_INIT_FRAME_r01, + _DELETE_DEREF_r00, + _DELETE_FAST_r00, + _DELETE_SUBSCR_r20, + _DEOPT_r00, + _DEOPT_r10, + _DEOPT_r20, + _DEOPT_r30, + _DICT_MERGE_r11, + _DICT_UPDATE_r11, + _DO_CALL_r01, + _DO_CALL_FUNCTION_EX_r31, + _DO_CALL_KW_r11, + _DYNAMIC_EXIT_r00, + _DYNAMIC_EXIT_r10, + _DYNAMIC_EXIT_r20, + _DYNAMIC_EXIT_r30, + _END_FOR_r10, + _END_SEND_r31, + _ERROR_POP_N_r00, + _EXIT_INIT_CHECK_r10, + _EXIT_TRACE_r00, + _EXIT_TRACE_r10, + _EXIT_TRACE_r20, + _EXIT_TRACE_r30, + _EXPAND_METHOD_r00, + _EXPAND_METHOD_KW_r11, + _FATAL_ERROR_r00, + _FATAL_ERROR_r11, + _FATAL_ERROR_r22, + _FATAL_ERROR_r33, + _FORMAT_SIMPLE_r11, + _FORMAT_WITH_SPEC_r21, + _FOR_ITER_r23, + _FOR_ITER_GEN_FRAME_r03, + _FOR_ITER_GEN_FRAME_r13, + _FOR_ITER_GEN_FRAME_r23, + _FOR_ITER_TIER_TWO_r23, + _FOR_ITER_VIRTUAL_r23, + _FOR_ITER_VIRTUAL_TIER_TWO_r23, + _GET_AITER_r11, + _GET_ANEXT_r12, + _GET_AWAITABLE_r11, + _GET_ITER_r12, + _GET_ITER_TRAD_r12, + _GET_LEN_r12, + _GUARD_3OS_ASYNC_GEN_ASEND_r03, + _GUARD_3OS_ASYNC_GEN_ASEND_r13, + _GUARD_3OS_ASYNC_GEN_ASEND_r23, + _GUARD_3OS_ASYNC_GEN_ASEND_r33, + _GUARD_BINARY_OP_EXTEND_r22, + _GUARD_BINARY_OP_EXTEND_LHS_r02, + _GUARD_BINARY_OP_EXTEND_LHS_r12, + _GUARD_BINARY_OP_EXTEND_LHS_r22, + _GUARD_BINARY_OP_EXTEND_LHS_r33, + _GUARD_BINARY_OP_EXTEND_RHS_r02, + _GUARD_BINARY_OP_EXTEND_RHS_r12, + _GUARD_BINARY_OP_EXTEND_RHS_r22, + _GUARD_BINARY_OP_EXTEND_RHS_r33, + _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02, + _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12, + _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22, + _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33, + _GUARD_BIT_IS_SET_POP_r00, + _GUARD_BIT_IS_SET_POP_r10, + _GUARD_BIT_IS_SET_POP_r21, + _GUARD_BIT_IS_SET_POP_r32, + _GUARD_BIT_IS_SET_POP_4_r00, + _GUARD_BIT_IS_SET_POP_4_r10, + _GUARD_BIT_IS_SET_POP_4_r21, + _GUARD_BIT_IS_SET_POP_4_r32, + _GUARD_BIT_IS_SET_POP_5_r00, + _GUARD_BIT_IS_SET_POP_5_r10, + _GUARD_BIT_IS_SET_POP_5_r21, + _GUARD_BIT_IS_SET_POP_5_r32, + _GUARD_BIT_IS_SET_POP_6_r00, + _GUARD_BIT_IS_SET_POP_6_r10, + _GUARD_BIT_IS_SET_POP_6_r21, + _GUARD_BIT_IS_SET_POP_6_r32, + _GUARD_BIT_IS_SET_POP_7_r00, + _GUARD_BIT_IS_SET_POP_7_r10, + _GUARD_BIT_IS_SET_POP_7_r21, + _GUARD_BIT_IS_SET_POP_7_r32, + _GUARD_BIT_IS_UNSET_POP_r00, + _GUARD_BIT_IS_UNSET_POP_r10, + _GUARD_BIT_IS_UNSET_POP_r21, + _GUARD_BIT_IS_UNSET_POP_r32, + _GUARD_BIT_IS_UNSET_POP_4_r00, + _GUARD_BIT_IS_UNSET_POP_4_r10, + _GUARD_BIT_IS_UNSET_POP_4_r21, + _GUARD_BIT_IS_UNSET_POP_4_r32, + _GUARD_BIT_IS_UNSET_POP_5_r00, + _GUARD_BIT_IS_UNSET_POP_5_r10, + _GUARD_BIT_IS_UNSET_POP_5_r21, + _GUARD_BIT_IS_UNSET_POP_5_r32, + _GUARD_BIT_IS_UNSET_POP_6_r00, + _GUARD_BIT_IS_UNSET_POP_6_r10, + _GUARD_BIT_IS_UNSET_POP_6_r21, + _GUARD_BIT_IS_UNSET_POP_6_r32, + _GUARD_BIT_IS_UNSET_POP_7_r00, + _GUARD_BIT_IS_UNSET_POP_7_r10, + _GUARD_BIT_IS_UNSET_POP_7_r21, + _GUARD_BIT_IS_UNSET_POP_7_r32, + _GUARD_CALLABLE_BUILTIN_CLASS_r00, + _GUARD_CALLABLE_BUILTIN_FAST_r00, + _GUARD_CALLABLE_BUILTIN_FAST_WITH_KEYWORDS_r00, + _GUARD_CALLABLE_BUILTIN_O_r00, + _GUARD_CALLABLE_ISINSTANCE_r03, + _GUARD_CALLABLE_ISINSTANCE_r13, + _GUARD_CALLABLE_ISINSTANCE_r23, + _GUARD_CALLABLE_ISINSTANCE_r33, + _GUARD_CALLABLE_LEN_r03, + _GUARD_CALLABLE_LEN_r13, + _GUARD_CALLABLE_LEN_r23, + _GUARD_CALLABLE_LEN_r33, + _GUARD_CALLABLE_LIST_APPEND_r03, + _GUARD_CALLABLE_LIST_APPEND_r13, + _GUARD_CALLABLE_LIST_APPEND_r23, + _GUARD_CALLABLE_LIST_APPEND_r33, + _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_r00, + _GUARD_CALLABLE_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r00, + _GUARD_CALLABLE_METHOD_DESCRIPTOR_NOARGS_r00, + _GUARD_CALLABLE_METHOD_DESCRIPTOR_O_r00, + _GUARD_CALLABLE_STR_1_r03, + _GUARD_CALLABLE_STR_1_r13, + _GUARD_CALLABLE_STR_1_r23, + _GUARD_CALLABLE_STR_1_r33, + _GUARD_CALLABLE_TUPLE_1_r03, + _GUARD_CALLABLE_TUPLE_1_r13, + _GUARD_CALLABLE_TUPLE_1_r23, + _GUARD_CALLABLE_TUPLE_1_r33, + _GUARD_CALLABLE_TYPE_1_r03, + _GUARD_CALLABLE_TYPE_1_r13, + _GUARD_CALLABLE_TYPE_1_r23, + _GUARD_CALLABLE_TYPE_1_r33, + _GUARD_CODE_VERSION_RETURN_GENERATOR_r00, + _GUARD_CODE_VERSION_RETURN_GENERATOR_r11, + _GUARD_CODE_VERSION_RETURN_GENERATOR_r22, + _GUARD_CODE_VERSION_RETURN_GENERATOR_r33, + _GUARD_CODE_VERSION_RETURN_VALUE_r00, + _GUARD_CODE_VERSION_RETURN_VALUE_r11, + _GUARD_CODE_VERSION_RETURN_VALUE_r22, + _GUARD_CODE_VERSION_RETURN_VALUE_r33, + _GUARD_CODE_VERSION_YIELD_VALUE_r00, + _GUARD_CODE_VERSION_YIELD_VALUE_r11, + _GUARD_CODE_VERSION_YIELD_VALUE_r22, + _GUARD_CODE_VERSION_YIELD_VALUE_r33, + _GUARD_CODE_VERSION__PUSH_FRAME_r00, + _GUARD_CODE_VERSION__PUSH_FRAME_r11, + _GUARD_CODE_VERSION__PUSH_FRAME_r22, + _GUARD_CODE_VERSION__PUSH_FRAME_r33, + _GUARD_DORV_NO_DICT_r01, + _GUARD_DORV_NO_DICT_r11, + _GUARD_DORV_NO_DICT_r22, + _GUARD_DORV_NO_DICT_r33, + _GUARD_GLOBALS_VERSION_r00, + _GUARD_GLOBALS_VERSION_r11, + _GUARD_GLOBALS_VERSION_r22, + _GUARD_GLOBALS_VERSION_r33, + _GUARD_IP_RETURN_GENERATOR_r00, + _GUARD_IP_RETURN_GENERATOR_r11, + _GUARD_IP_RETURN_GENERATOR_r22, + _GUARD_IP_RETURN_GENERATOR_r33, + _GUARD_IP_RETURN_VALUE_r00, + _GUARD_IP_RETURN_VALUE_r11, + _GUARD_IP_RETURN_VALUE_r22, + _GUARD_IP_RETURN_VALUE_r33, + _GUARD_IP_YIELD_VALUE_r00, + _GUARD_IP_YIELD_VALUE_r11, + _GUARD_IP_YIELD_VALUE_r22, + _GUARD_IP_YIELD_VALUE_r33, + _GUARD_IP__PUSH_FRAME_r00, + _GUARD_IP__PUSH_FRAME_r11, + _GUARD_IP__PUSH_FRAME_r22, + _GUARD_IP__PUSH_FRAME_r33, + _GUARD_IS_FALSE_POP_r00, + _GUARD_IS_FALSE_POP_r10, + _GUARD_IS_FALSE_POP_r21, + _GUARD_IS_FALSE_POP_r32, + _GUARD_IS_NONE_POP_r00, + _GUARD_IS_NONE_POP_r10, + _GUARD_IS_NONE_POP_r21, + _GUARD_IS_NONE_POP_r32, + _GUARD_IS_NOT_NONE_POP_r10, + _GUARD_IS_TRUE_POP_r00, + _GUARD_IS_TRUE_POP_r10, + _GUARD_IS_TRUE_POP_r21, + _GUARD_IS_TRUE_POP_r32, + _GUARD_ITERATOR_r01, + _GUARD_ITERATOR_r11, + _GUARD_ITERATOR_r22, + _GUARD_ITERATOR_r33, + _GUARD_ITER_VIRTUAL_r01, + _GUARD_ITER_VIRTUAL_r11, + _GUARD_ITER_VIRTUAL_r22, + _GUARD_ITER_VIRTUAL_r33, + _GUARD_LOAD_SUPER_ATTR_METHOD_r03, + _GUARD_LOAD_SUPER_ATTR_METHOD_r13, + _GUARD_LOAD_SUPER_ATTR_METHOD_r23, + _GUARD_LOAD_SUPER_ATTR_METHOD_r33, + _GUARD_NOS_COMPACT_ASCII_r02, + _GUARD_NOS_COMPACT_ASCII_r12, + _GUARD_NOS_COMPACT_ASCII_r22, + _GUARD_NOS_COMPACT_ASCII_r33, + _GUARD_NOS_DICT_STORE_SUBSCRIPT_r03, + _GUARD_NOS_DICT_STORE_SUBSCRIPT_r13, + _GUARD_NOS_DICT_STORE_SUBSCRIPT_r23, + _GUARD_NOS_DICT_STORE_SUBSCRIPT_r33, + _GUARD_NOS_DICT_SUBSCRIPT_r02, + _GUARD_NOS_DICT_SUBSCRIPT_r12, + _GUARD_NOS_DICT_SUBSCRIPT_r22, + _GUARD_NOS_DICT_SUBSCRIPT_r33, + _GUARD_NOS_FLOAT_r02, + _GUARD_NOS_FLOAT_r12, + _GUARD_NOS_FLOAT_r22, + _GUARD_NOS_FLOAT_r33, + _GUARD_NOS_INT_r02, + _GUARD_NOS_INT_r12, + _GUARD_NOS_INT_r22, + _GUARD_NOS_INT_r33, + _GUARD_NOS_ITER_VIRTUAL_r02, + _GUARD_NOS_ITER_VIRTUAL_r12, + _GUARD_NOS_ITER_VIRTUAL_r22, + _GUARD_NOS_ITER_VIRTUAL_r33, + _GUARD_NOS_LIST_r02, + _GUARD_NOS_LIST_r12, + _GUARD_NOS_LIST_r22, + _GUARD_NOS_LIST_r33, + _GUARD_NOS_NOT_NULL_r02, + _GUARD_NOS_NOT_NULL_r12, + _GUARD_NOS_NOT_NULL_r22, + _GUARD_NOS_NOT_NULL_r33, + _GUARD_NOS_NULL_r02, + _GUARD_NOS_NULL_r12, + _GUARD_NOS_NULL_r22, + _GUARD_NOS_NULL_r33, + _GUARD_NOS_OVERFLOWED_r02, + _GUARD_NOS_OVERFLOWED_r12, + _GUARD_NOS_OVERFLOWED_r22, + _GUARD_NOS_OVERFLOWED_r33, + _GUARD_NOS_TUPLE_r02, + _GUARD_NOS_TUPLE_r12, + _GUARD_NOS_TUPLE_r22, + _GUARD_NOS_TUPLE_r33, + _GUARD_NOS_TYPE_VERSION_r02, + _GUARD_NOS_TYPE_VERSION_r12, + _GUARD_NOS_TYPE_VERSION_r22, + _GUARD_NOS_TYPE_VERSION_r33, + _GUARD_NOS_UNICODE_r02, + _GUARD_NOS_UNICODE_r12, + _GUARD_NOS_UNICODE_r22, + _GUARD_NOS_UNICODE_r33, + _GUARD_NOT_EXHAUSTED_LIST_r02, + _GUARD_NOT_EXHAUSTED_LIST_r12, + _GUARD_NOT_EXHAUSTED_LIST_r22, + _GUARD_NOT_EXHAUSTED_LIST_r33, + _GUARD_NOT_EXHAUSTED_RANGE_r02, + _GUARD_NOT_EXHAUSTED_RANGE_r12, + _GUARD_NOT_EXHAUSTED_RANGE_r22, + _GUARD_NOT_EXHAUSTED_RANGE_r33, + _GUARD_NOT_EXHAUSTED_TUPLE_r02, + _GUARD_NOT_EXHAUSTED_TUPLE_r12, + _GUARD_NOT_EXHAUSTED_TUPLE_r22, + _GUARD_NOT_EXHAUSTED_TUPLE_r33, + _GUARD_THIRD_NULL_r03, + _GUARD_THIRD_NULL_r13, + _GUARD_THIRD_NULL_r23, + _GUARD_THIRD_NULL_r33, + _GUARD_TOS_ANY_DICT_r01, + _GUARD_TOS_ANY_DICT_r11, + _GUARD_TOS_ANY_DICT_r22, + _GUARD_TOS_ANY_DICT_r33, + _GUARD_TOS_ANY_SET_r01, + _GUARD_TOS_ANY_SET_r11, + _GUARD_TOS_ANY_SET_r22, + _GUARD_TOS_ANY_SET_r33, + _GUARD_TOS_DICT_r01, + _GUARD_TOS_DICT_r11, + _GUARD_TOS_DICT_r22, + _GUARD_TOS_DICT_r33, + _GUARD_TOS_FLOAT_r01, + _GUARD_TOS_FLOAT_r11, + _GUARD_TOS_FLOAT_r22, + _GUARD_TOS_FLOAT_r33, + _GUARD_TOS_FROZENDICT_r01, + _GUARD_TOS_FROZENDICT_r11, + _GUARD_TOS_FROZENDICT_r22, + _GUARD_TOS_FROZENDICT_r33, + _GUARD_TOS_FROZENSET_r01, + _GUARD_TOS_FROZENSET_r11, + _GUARD_TOS_FROZENSET_r22, + _GUARD_TOS_FROZENSET_r33, + _GUARD_TOS_INT_r01, + _GUARD_TOS_INT_r11, + _GUARD_TOS_INT_r22, + _GUARD_TOS_INT_r33, + _GUARD_TOS_IS_NONE_r01, + _GUARD_TOS_IS_NONE_r11, + _GUARD_TOS_IS_NONE_r22, + _GUARD_TOS_IS_NONE_r33, + _GUARD_TOS_LIST_r01, + _GUARD_TOS_LIST_r11, + _GUARD_TOS_LIST_r22, + _GUARD_TOS_LIST_r33, + _GUARD_TOS_NOT_NULL_r01, + _GUARD_TOS_NOT_NULL_r11, + _GUARD_TOS_NOT_NULL_r22, + _GUARD_TOS_NOT_NULL_r33, + _GUARD_TOS_OVERFLOWED_r01, + _GUARD_TOS_OVERFLOWED_r11, + _GUARD_TOS_OVERFLOWED_r22, + _GUARD_TOS_OVERFLOWED_r33, + _GUARD_TOS_SET_r01, + _GUARD_TOS_SET_r11, + _GUARD_TOS_SET_r22, + _GUARD_TOS_SET_r33, + _GUARD_TOS_SLICE_r01, + _GUARD_TOS_SLICE_r11, + _GUARD_TOS_SLICE_r22, + _GUARD_TOS_SLICE_r33, + _GUARD_TOS_TUPLE_r01, + _GUARD_TOS_TUPLE_r11, + _GUARD_TOS_TUPLE_r22, + _GUARD_TOS_TUPLE_r33, + _GUARD_TOS_UNICODE_r01, + _GUARD_TOS_UNICODE_r11, + _GUARD_TOS_UNICODE_r22, + _GUARD_TOS_UNICODE_r33, + _GUARD_TYPE_r01, + _GUARD_TYPE_r11, + _GUARD_TYPE_r22, + _GUARD_TYPE_r33, + _GUARD_TYPE_ITER_r02, + _GUARD_TYPE_ITER_r12, + _GUARD_TYPE_ITER_r22, + _GUARD_TYPE_ITER_r33, + _GUARD_TYPE_VERSION_r01, + _GUARD_TYPE_VERSION_r11, + _GUARD_TYPE_VERSION_r22, + _GUARD_TYPE_VERSION_r33, + _GUARD_TYPE_VERSION_LOCKED_r01, + _GUARD_TYPE_VERSION_LOCKED_r11, + _GUARD_TYPE_VERSION_LOCKED_r22, + _GUARD_TYPE_VERSION_LOCKED_r33, + _HANDLE_PENDING_AND_DEOPT_r00, + _HANDLE_PENDING_AND_DEOPT_r10, + _HANDLE_PENDING_AND_DEOPT_r20, + _HANDLE_PENDING_AND_DEOPT_r30, + _IMPORT_FROM_r12, + _IMPORT_NAME_r21, + _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00, + _INIT_CALL_PY_EXACT_ARGS_r01, + _INIT_CALL_PY_EXACT_ARGS_0_r01, + _INIT_CALL_PY_EXACT_ARGS_1_r01, + _INIT_CALL_PY_EXACT_ARGS_2_r01, + _INIT_CALL_PY_EXACT_ARGS_3_r01, + _INIT_CALL_PY_EXACT_ARGS_4_r01, + _INSERT_NULL_r10, + _INSTRUMENTED_FOR_ITER_r23, + _INSTRUMENTED_INSTRUCTION_r00, + _INSTRUMENTED_JUMP_FORWARD_r00, + _INSTRUMENTED_JUMP_FORWARD_r11, + _INSTRUMENTED_JUMP_FORWARD_r22, + _INSTRUMENTED_JUMP_FORWARD_r33, + _INSTRUMENTED_LINE_r00, + _INSTRUMENTED_NOT_TAKEN_r00, + _INSTRUMENTED_NOT_TAKEN_r11, + _INSTRUMENTED_NOT_TAKEN_r22, + _INSTRUMENTED_NOT_TAKEN_r33, + _INSTRUMENTED_POP_JUMP_IF_FALSE_r00, + _INSTRUMENTED_POP_JUMP_IF_FALSE_r10, + _INSTRUMENTED_POP_JUMP_IF_FALSE_r21, + _INSTRUMENTED_POP_JUMP_IF_FALSE_r32, + _INSTRUMENTED_POP_JUMP_IF_NONE_r10, + _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10, + _INSTRUMENTED_POP_JUMP_IF_TRUE_r00, + _INSTRUMENTED_POP_JUMP_IF_TRUE_r10, + _INSTRUMENTED_POP_JUMP_IF_TRUE_r21, + _INSTRUMENTED_POP_JUMP_IF_TRUE_r32, + _IS_NONE_r11, + _IS_OP_r03, + _IS_OP_r13, + _IS_OP_r23, + _ITER_CHECK_LIST_r02, + _ITER_CHECK_LIST_r12, + _ITER_CHECK_LIST_r22, + _ITER_CHECK_LIST_r33, + _ITER_CHECK_RANGE_r02, + _ITER_CHECK_RANGE_r12, + _ITER_CHECK_RANGE_r22, + _ITER_CHECK_RANGE_r33, + _ITER_CHECK_TUPLE_r02, + _ITER_CHECK_TUPLE_r12, + _ITER_CHECK_TUPLE_r22, + _ITER_CHECK_TUPLE_r33, + _ITER_JUMP_LIST_r02, + _ITER_JUMP_LIST_r12, + _ITER_JUMP_LIST_r22, + _ITER_JUMP_LIST_r33, + _ITER_JUMP_RANGE_r02, + _ITER_JUMP_RANGE_r12, + _ITER_JUMP_RANGE_r22, + _ITER_JUMP_RANGE_r33, + _ITER_JUMP_TUPLE_r02, + _ITER_JUMP_TUPLE_r12, + _ITER_JUMP_TUPLE_r22, + _ITER_JUMP_TUPLE_r33, + _ITER_NEXT_INLINE_r23, + _ITER_NEXT_LIST_r23, + _ITER_NEXT_LIST_TIER_TWO_r23, + _ITER_NEXT_RANGE_r03, + _ITER_NEXT_RANGE_r13, + _ITER_NEXT_RANGE_r23, + _ITER_NEXT_TUPLE_r03, + _ITER_NEXT_TUPLE_r13, + _ITER_NEXT_TUPLE_r23, + _JUMP_BACKWARD_NO_INTERRUPT_r00, + _JUMP_BACKWARD_NO_INTERRUPT_r11, + _JUMP_BACKWARD_NO_INTERRUPT_r22, + _JUMP_BACKWARD_NO_INTERRUPT_r33, + _JUMP_TO_TOP_r00, + _LIST_APPEND_r10, + _LIST_EXTEND_r11, + _LOAD_ATTR_r10, + _LOAD_ATTR_CLASS_r11, + _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_FRAME_r11, + _LOAD_ATTR_INSTANCE_VALUE_r02, + _LOAD_ATTR_INSTANCE_VALUE_r12, + _LOAD_ATTR_INSTANCE_VALUE_r23, + _LOAD_ATTR_METHOD_LAZY_DICT_r02, + _LOAD_ATTR_METHOD_LAZY_DICT_r12, + _LOAD_ATTR_METHOD_LAZY_DICT_r23, + _LOAD_ATTR_METHOD_NO_DICT_r02, + _LOAD_ATTR_METHOD_NO_DICT_r12, + _LOAD_ATTR_METHOD_NO_DICT_r23, + _LOAD_ATTR_METHOD_WITH_VALUES_r02, + _LOAD_ATTR_METHOD_WITH_VALUES_r12, + _LOAD_ATTR_METHOD_WITH_VALUES_r23, + _LOAD_ATTR_MODULE_r12, + _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11, + _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11, + _LOAD_ATTR_PROPERTY_FRAME_r01, + _LOAD_ATTR_PROPERTY_FRAME_r11, + _LOAD_ATTR_PROPERTY_FRAME_r22, + _LOAD_ATTR_PROPERTY_FRAME_r33, + _LOAD_ATTR_SLOT_r02, + _LOAD_ATTR_SLOT_r12, + _LOAD_ATTR_SLOT_r23, + _LOAD_ATTR_WITH_HINT_r12, + _LOAD_BUILD_CLASS_r01, + _LOAD_BYTECODE_r00, + _LOAD_COMMON_CONSTANT_r01, + _LOAD_COMMON_CONSTANT_r12, + _LOAD_COMMON_CONSTANT_r23, + _LOAD_CONST_r01, + _LOAD_CONST_r12, + _LOAD_CONST_r23, + _LOAD_CONST_INLINE_r01, + _LOAD_CONST_INLINE_r12, + _LOAD_CONST_INLINE_r23, + _LOAD_CONST_INLINE_BORROW_r01, + _LOAD_CONST_INLINE_BORROW_r12, + _LOAD_CONST_INLINE_BORROW_r23, + _LOAD_DEREF_r01, + _LOAD_FAST_r01, + _LOAD_FAST_r12, + _LOAD_FAST_r23, + _LOAD_FAST_0_r01, + _LOAD_FAST_0_r12, + _LOAD_FAST_0_r23, + _LOAD_FAST_1_r01, + _LOAD_FAST_1_r12, + _LOAD_FAST_1_r23, + _LOAD_FAST_2_r01, + _LOAD_FAST_2_r12, + _LOAD_FAST_2_r23, + _LOAD_FAST_3_r01, + _LOAD_FAST_3_r12, + _LOAD_FAST_3_r23, + _LOAD_FAST_4_r01, + _LOAD_FAST_4_r12, + _LOAD_FAST_4_r23, + _LOAD_FAST_5_r01, + _LOAD_FAST_5_r12, + _LOAD_FAST_5_r23, + _LOAD_FAST_6_r01, + _LOAD_FAST_6_r12, + _LOAD_FAST_6_r23, + _LOAD_FAST_7_r01, + _LOAD_FAST_7_r12, + _LOAD_FAST_7_r23, + _LOAD_FAST_AND_CLEAR_r01, + _LOAD_FAST_AND_CLEAR_r12, + _LOAD_FAST_AND_CLEAR_r23, + _LOAD_FAST_BORROW_r01, + _LOAD_FAST_BORROW_r12, + _LOAD_FAST_BORROW_r23, + _LOAD_FAST_BORROW_0_r01, + _LOAD_FAST_BORROW_0_r12, + _LOAD_FAST_BORROW_0_r23, + _LOAD_FAST_BORROW_1_r01, + _LOAD_FAST_BORROW_1_r12, + _LOAD_FAST_BORROW_1_r23, + _LOAD_FAST_BORROW_2_r01, + _LOAD_FAST_BORROW_2_r12, + _LOAD_FAST_BORROW_2_r23, + _LOAD_FAST_BORROW_3_r01, + _LOAD_FAST_BORROW_3_r12, + _LOAD_FAST_BORROW_3_r23, + _LOAD_FAST_BORROW_4_r01, + _LOAD_FAST_BORROW_4_r12, + _LOAD_FAST_BORROW_4_r23, + _LOAD_FAST_BORROW_5_r01, + _LOAD_FAST_BORROW_5_r12, + _LOAD_FAST_BORROW_5_r23, + _LOAD_FAST_BORROW_6_r01, + _LOAD_FAST_BORROW_6_r12, + _LOAD_FAST_BORROW_6_r23, + _LOAD_FAST_BORROW_7_r01, + _LOAD_FAST_BORROW_7_r12, + _LOAD_FAST_BORROW_7_r23, + _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02, + _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13, + _LOAD_FAST_CHECK_r01, + _LOAD_FAST_CHECK_r12, + _LOAD_FAST_CHECK_r23, + _LOAD_FAST_LOAD_FAST_r02, + _LOAD_FAST_LOAD_FAST_r13, + _LOAD_FROM_DICT_OR_DEREF_r11, + _LOAD_FROM_DICT_OR_GLOBALS_r11, + _LOAD_GLOBAL_r00, + _LOAD_GLOBAL_BUILTINS_r01, + _LOAD_GLOBAL_MODULE_r01, + _LOAD_LOCALS_r01, + _LOAD_LOCALS_r12, + _LOAD_LOCALS_r23, + _LOAD_NAME_r01, + _LOAD_SMALL_INT_r01, + _LOAD_SMALL_INT_r12, + _LOAD_SMALL_INT_r23, + _LOAD_SMALL_INT_0_r01, + _LOAD_SMALL_INT_0_r12, + _LOAD_SMALL_INT_0_r23, + _LOAD_SMALL_INT_1_r01, + _LOAD_SMALL_INT_1_r12, + _LOAD_SMALL_INT_1_r23, + _LOAD_SMALL_INT_2_r01, + _LOAD_SMALL_INT_2_r12, + _LOAD_SMALL_INT_2_r23, + _LOAD_SMALL_INT_3_r01, + _LOAD_SMALL_INT_3_r12, + _LOAD_SMALL_INT_3_r23, + _LOAD_SPECIAL_r00, + _LOAD_SUPER_ATTR_ATTR_r31, + _LOAD_SUPER_ATTR_METHOD_r32, + _LOCK_OBJECT_r01, + _LOCK_OBJECT_r11, + _LOCK_OBJECT_r22, + _LOCK_OBJECT_r33, + _MAKE_CALLARGS_A_TUPLE_r33, + _MAKE_CELL_r00, + _MAKE_FUNCTION_r12, + _MAKE_HEAP_SAFE_r01, + _MAKE_HEAP_SAFE_r11, + _MAKE_HEAP_SAFE_r22, + _MAKE_HEAP_SAFE_r33, + _MAKE_WARM_r00, + _MAKE_WARM_r11, + _MAKE_WARM_r22, + _MAKE_WARM_r33, + _MAP_ADD_r20, + _MATCH_CLASS_r33, + _MATCH_KEYS_r23, + _MATCH_MAPPING_r02, + _MATCH_MAPPING_r12, + _MATCH_MAPPING_r23, + _MATCH_SEQUENCE_r02, + _MATCH_SEQUENCE_r12, + _MATCH_SEQUENCE_r23, + _MAYBE_EXPAND_METHOD_r00, + _MAYBE_EXPAND_METHOD_KW_r11, + _MONITOR_CALL_r00, + _MONITOR_CALL_KW_r11, + _MONITOR_JUMP_BACKWARD_r00, + _MONITOR_JUMP_BACKWARD_r11, + _MONITOR_JUMP_BACKWARD_r22, + _MONITOR_JUMP_BACKWARD_r33, + _MONITOR_RESUME_r00, + _NOP_r00, + _NOP_r11, + _NOP_r22, + _NOP_r33, + _POP_EXCEPT_r10, + _POP_ITER_r20, + _POP_JUMP_IF_FALSE_r00, + _POP_JUMP_IF_FALSE_r10, + _POP_JUMP_IF_FALSE_r21, + _POP_JUMP_IF_FALSE_r32, + _POP_JUMP_IF_TRUE_r00, + _POP_JUMP_IF_TRUE_r10, + _POP_JUMP_IF_TRUE_r21, + _POP_JUMP_IF_TRUE_r32, + _POP_TOP_r10, + _POP_TOP_FLOAT_r00, + _POP_TOP_FLOAT_r10, + _POP_TOP_FLOAT_r21, + _POP_TOP_FLOAT_r32, + _POP_TOP_INT_r00, + _POP_TOP_INT_r10, + _POP_TOP_INT_r21, + _POP_TOP_INT_r32, + _POP_TOP_NOP_r00, + _POP_TOP_NOP_r10, + _POP_TOP_NOP_r21, + _POP_TOP_NOP_r32, + _POP_TOP_OPARG_r00, + _POP_TOP_UNICODE_r00, + _POP_TOP_UNICODE_r10, + _POP_TOP_UNICODE_r21, + _POP_TOP_UNICODE_r32, + _PUSH_EXC_INFO_r02, + _PUSH_EXC_INFO_r12, + _PUSH_EXC_INFO_r23, + _PUSH_FRAME_r10, + _PUSH_NULL_r01, + _PUSH_NULL_r12, + _PUSH_NULL_r23, + _PUSH_NULL_CONDITIONAL_r00, + _PUSH_TAGGED_ZERO_r01, + _PUSH_TAGGED_ZERO_r12, + _PUSH_TAGGED_ZERO_r23, + _PY_FRAME_EX_r31, + _PY_FRAME_GENERAL_r01, + _PY_FRAME_KW_r11, + _REPLACE_WITH_TRUE_r02, + _REPLACE_WITH_TRUE_r12, + _REPLACE_WITH_TRUE_r23, + _RESUME_CHECK_r00, + _RESUME_CHECK_r11, + _RESUME_CHECK_r22, + _RESUME_CHECK_r33, + _RETURN_GENERATOR_r01, + _RETURN_VALUE_r11, + _RROT_3_r03, + _RROT_3_r13, + _RROT_3_r23, + _RROT_3_r33, + _SAVE_RETURN_OFFSET_r00, + _SAVE_RETURN_OFFSET_r11, + _SAVE_RETURN_OFFSET_r22, + _SAVE_RETURN_OFFSET_r33, + _SEND_ASYNC_GEN_r33, + _SEND_ASYNC_GEN_TIER_TWO_r33, + _SEND_GEN_FRAME_r33, + _SEND_VIRTUAL_r33, + _SEND_VIRTUAL_TIER_TWO_r03, + _SEND_VIRTUAL_TIER_TWO_r13, + _SEND_VIRTUAL_TIER_TWO_r23, + _SEND_VIRTUAL_TIER_TWO_r33, + _SETUP_ANNOTATIONS_r00, + _SET_ADD_r10, + _SET_FUNCTION_ATTRIBUTE_r01, + _SET_FUNCTION_ATTRIBUTE_r11, + _SET_FUNCTION_ATTRIBUTE_r21, + _SET_FUNCTION_ATTRIBUTE_r32, + _SET_IP_r00, + _SET_IP_r11, + _SET_IP_r22, + _SET_IP_r33, + _SET_UPDATE_r11, + _SPILL_OR_RELOAD_r01, + _SPILL_OR_RELOAD_r02, + _SPILL_OR_RELOAD_r03, + _SPILL_OR_RELOAD_r10, + _SPILL_OR_RELOAD_r12, + _SPILL_OR_RELOAD_r13, + _SPILL_OR_RELOAD_r20, + _SPILL_OR_RELOAD_r21, + _SPILL_OR_RELOAD_r23, + _SPILL_OR_RELOAD_r30, + _SPILL_OR_RELOAD_r31, + _SPILL_OR_RELOAD_r32, + _START_EXECUTOR_r00, + _STORE_ATTR_r20, + _STORE_ATTR_INSTANCE_VALUE_r21, + _STORE_ATTR_SLOT_r21, + _STORE_ATTR_WITH_HINT_r21, + _STORE_DEREF_r10, + _STORE_FAST_LOAD_FAST_r11, + _STORE_FAST_STORE_FAST_r20, + _STORE_GLOBAL_r10, + _STORE_NAME_r10, + _STORE_SLICE_r30, + _STORE_SUBSCR_r30, + _STORE_SUBSCR_DICT_r31, + _STORE_SUBSCR_DICT_KNOWN_HASH_r31, + _STORE_SUBSCR_LIST_INT_r32, + _SWAP_r11, + _SWAP_2_r02, + _SWAP_2_r12, + _SWAP_2_r22, + _SWAP_2_r33, + _SWAP_3_r03, + _SWAP_3_r13, + _SWAP_3_r23, + _SWAP_3_r33, + _SWAP_FAST_r01, + _SWAP_FAST_r11, + _SWAP_FAST_r22, + _SWAP_FAST_r33, + _SWAP_FAST_0_r01, + _SWAP_FAST_0_r11, + _SWAP_FAST_0_r22, + _SWAP_FAST_0_r33, + _SWAP_FAST_1_r01, + _SWAP_FAST_1_r11, + _SWAP_FAST_1_r22, + _SWAP_FAST_1_r33, + _SWAP_FAST_2_r01, + _SWAP_FAST_2_r11, + _SWAP_FAST_2_r22, + _SWAP_FAST_2_r33, + _SWAP_FAST_3_r01, + _SWAP_FAST_3_r11, + _SWAP_FAST_3_r22, + _SWAP_FAST_3_r33, + _SWAP_FAST_4_r01, + _SWAP_FAST_4_r11, + _SWAP_FAST_4_r22, + _SWAP_FAST_4_r33, + _SWAP_FAST_5_r01, + _SWAP_FAST_5_r11, + _SWAP_FAST_5_r22, + _SWAP_FAST_5_r33, + _SWAP_FAST_6_r01, + _SWAP_FAST_6_r11, + _SWAP_FAST_6_r22, + _SWAP_FAST_6_r33, + _SWAP_FAST_7_r01, + _SWAP_FAST_7_r11, + _SWAP_FAST_7_r22, + _SWAP_FAST_7_r33, + _TIER2_RESUME_CHECK_r00, + _TIER2_RESUME_CHECK_r11, + _TIER2_RESUME_CHECK_r22, + _TIER2_RESUME_CHECK_r33, + _TO_BOOL_r11, + _TO_BOOL_BOOL_r01, + _TO_BOOL_BOOL_r11, + _TO_BOOL_BOOL_r22, + _TO_BOOL_BOOL_r33, + _TO_BOOL_INT_r02, + _TO_BOOL_INT_r12, + _TO_BOOL_INT_r23, + _TO_BOOL_LIST_r02, + _TO_BOOL_LIST_r12, + _TO_BOOL_LIST_r23, + _TO_BOOL_NONE_r01, + _TO_BOOL_NONE_r11, + _TO_BOOL_NONE_r22, + _TO_BOOL_NONE_r33, + _TO_BOOL_STR_r02, + _TO_BOOL_STR_r12, + _TO_BOOL_STR_r23, + _TRACE_RECORD_r00, + _UNARY_INVERT_r12, + _UNARY_NEGATIVE_r12, + _UNARY_NEGATIVE_FLOAT_INPLACE_r02, + _UNARY_NEGATIVE_FLOAT_INPLACE_r12, + _UNARY_NEGATIVE_FLOAT_INPLACE_r23, + _UNARY_NOT_r01, + _UNARY_NOT_r11, + _UNARY_NOT_r22, + _UNARY_NOT_r33, + _UNPACK_EX_r10, + _UNPACK_SEQUENCE_r10, + _UNPACK_SEQUENCE_LIST_r10, + _UNPACK_SEQUENCE_TUPLE_r10, + _UNPACK_SEQUENCE_TWO_TUPLE_r12, + _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r03, + _UNPACK_SEQUENCE_UNIQUE_THREE_TUPLE_r13, + _UNPACK_SEQUENCE_UNIQUE_TUPLE_r10, + _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r02, + _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r12, + _UNPACK_SEQUENCE_UNIQUE_TWO_TUPLE_r23, + _WITH_EXCEPT_START_r33, + _YIELD_VALUE_r11, +}; #define MAX_UOP_REGS_ID 1645 #ifdef __cplusplus diff --git a/Tools/cases_generator/uop_id_generator.py b/Tools/cases_generator/uop_id_generator.py index b059a4a169c1ae6..5b8303962873e40 100644 --- a/Tools/cases_generator/uop_id_generator.py +++ b/Tools/cases_generator/uop_id_generator.py @@ -28,35 +28,71 @@ def generate_uop_ids( write_header(__file__, filenames, outfile) out = CWriter(outfile, 0, False) with out.header_guard("Py_CORE_UOP_IDS_H"): - next_id = 1 if distinct_namespace else 300 - # These two are first by convention - out.emit(f"#define _EXIT_TRACE {next_id}\n") - next_id += 1 - out.emit(f"#define _SET_IP {next_id}\n") - next_id += 1 + start_id = 1 if distinct_namespace else 300 + # next_id only tracks the sequentially numbered ids so that the + # MAX_UOP_ID / MAX_UOP_REGS_ID macros below can be emitted as plain + # integer literals (they are used in preprocessor #if conditions, + # which cannot see enum constants). + next_id = start_id PRE_DEFINED = {"_EXIT_TRACE", "_SET_IP"} uops = [(uop.name, uop) for uop in analysis.uops.values()] - # Sort so that _BASE comes immediately before _BASE_0, etc. + # Sort so that _BASE comes immediately before _BASE_0, etc. Split the + # uops into those that get their own sequential id and those that are + # aliased to the matching tier 1 opcode id. + sequential_uops: list[str] = [] + aliased_uops: list[str] = [] for name, uop in sorted(uops): if name in PRE_DEFINED or uop.is_super() or uop.properties.tier == 1: continue if uop.implicitly_created and not distinct_namespace and not uop.replicated: - out.emit(f"#define {name} {name[1:]}\n") + aliased_uops.append(name) else: - out.emit(f"#define {name} {next_id}\n") - next_id += 1 + sequential_uops.append(name) + + # Emit the ids as an enum with automatic numbering. This way adding or + # removing a uop only changes its own line (plus the MAX_* macros) + # instead of renumbering, and therefore rewriting, every line below it. + out.emit("enum {\n") + # _EXIT_TRACE and _SET_IP are first by convention. + out.emit(f"_EXIT_TRACE = {start_id},\n") + next_id += 1 + out.emit("_SET_IP,\n") + next_id += 1 + for name in sequential_uops: + out.emit(f"{name},\n") + next_id += 1 + out.emit("};\n") + out.emit(f"#define MAX_UOP_ID {next_id - 1}\n") + out.emit("\n") - out.emit(f"#define MAX_UOP_ID {next_id-1}\n") + # Uops implicitly created from a tier 1 instruction share that + # instruction's opcode id. These reference the tier 1 opcode name, so + # they never need renumbering; emit them as plain macros. + for name in aliased_uops: + out.emit(f"#define {name} {name[1:]}\n") + out.emit("\n") + + # The "register" variants are numbered immediately after the base uops. + reg_labels: list[str] = [] for name, uop in sorted(uops): if uop.properties.tier == 1: continue if uop.properties.records_value: continue for inputs, outputs, _ in sorted(get_uop_cache_depths(uop)): - out.emit(f"#define {name}_r{inputs}{outputs} {next_id}\n") + reg_labels.append(f"{name}_r{inputs}{outputs}") + + if reg_labels: + out.emit("enum {\n") + for i, label in enumerate(reg_labels): + if i == 0: + out.emit(f"{label} = MAX_UOP_ID + 1,\n") + else: + out.emit(f"{label},\n") next_id += 1 - out.emit(f"#define MAX_UOP_REGS_ID {next_id-1}\n") + out.emit("};\n") + out.emit(f"#define MAX_UOP_REGS_ID {next_id - 1}\n") arg_parser = argparse.ArgumentParser(