From 39ff3bdce3d3fee459d5d9057f789c713be91931 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Wed, 13 Dec 2023 19:46:07 +0000 Subject: [PATCH 01/51] Port metadata generation to new architecture. Work in progress --- Include/internal/pycore_opcode_metadata.h | 3024 ++++-------------- Include/internal/pycore_uop_ids.h | 4 +- Makefile.pre.in | 6 +- Python/assemble.c | 8 +- Python/ceval.c | 1 + Python/compile.c | 8 +- Python/executor_cases.c.h | 2 +- Python/flowgraph.c | 4 +- Python/generated_cases.c.h | 4 +- Python/optimizer.c | 7 +- Tools/cases_generator/analyzer.py | 12 + Tools/cases_generator/cwriter.py | 49 +- Tools/cases_generator/generators_common.py | 18 + Tools/cases_generator/opcode_id_generator.py | 32 +- Tools/cases_generator/uop_id_generator.py | 59 +- 15 files changed, 822 insertions(+), 2416 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 2c512d97c421c9..04cc8ce38c614d 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1,13 +1,35 @@ -// This file is generated by Tools/cases_generator/generate_cases.py +// This file is generated by Tools/cases_generator/opcode_metadata_generator.py // from: // Python/bytecodes.c // Do not edit! -#ifndef Py_BUILD_CORE -# error "this header requires Py_BUILD_CORE define" +#ifndef Py_CORE_OPCODE_METADATA_H +#define Py_CORE_OPCODE_METADATA_H +#ifdef __cplusplus +extern "C" { #endif -#include // bool +#include // bool +#include "opcode_ids.h" +#include "pycore_uops.h" +#define HAS_ARG_FLAG (1) +#define HAS_CONST_FLAG (2) +#define HAS_ERROR_FLAG (4) +#define HAS_NAME_FLAG (8) +#define HAS_FREE_FLAG (16) +#define HAS_JUMP_FLAG (32) +#define HAS_DEOPT_FLAG (64) +#define HAS_ESCAPES_FLAG (128) +#define HAS_LOCAL_FLAG (256) +#define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) +#define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) +#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) +#define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) +#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) +#define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) +#define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) +#define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) +#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) #define IS_PSEUDO_INSTR(OP) ( \ @@ -25,1991 +47,565 @@ ((OP) == POP_BLOCK) || \ 0) -#include "pycore_uop_ids.h" - -extern int _PyOpcode_num_popped(int opcode, int oparg, bool jump); -#ifdef NEED_OPCODE_METADATA -int _PyOpcode_num_popped(int opcode, int oparg, bool jump) { - switch(opcode) { - case NOP: - return 0; - case RESUME: - return 0; - case RESUME_CHECK: - return 0; - case INSTRUMENTED_RESUME: - return 0; - case LOAD_CLOSURE: - return 0; - case LOAD_FAST_CHECK: - return 0; - case LOAD_FAST: - return 0; - case LOAD_FAST_AND_CLEAR: - return 0; - case LOAD_FAST_LOAD_FAST: - return 0; - case LOAD_CONST: - return 0; - case STORE_FAST: - return 1; - case STORE_FAST_MAYBE_NULL: - return 1; - case STORE_FAST_LOAD_FAST: - return 1; - case STORE_FAST_STORE_FAST: - return 2; - case POP_TOP: - return 1; - case PUSH_NULL: - return 0; - case END_FOR: - return 2; - case INSTRUMENTED_END_FOR: - return 2; - case END_SEND: - return 2; - case INSTRUMENTED_END_SEND: - return 2; - case UNARY_NEGATIVE: - return 1; - case UNARY_NOT: - return 1; - case _SPECIALIZE_TO_BOOL: - return 1; - case _TO_BOOL: - return 1; - case TO_BOOL: - return 1; - case TO_BOOL_BOOL: - return 1; - case TO_BOOL_INT: - return 1; - case TO_BOOL_LIST: - return 1; - case TO_BOOL_NONE: - return 1; - case TO_BOOL_STR: - return 1; - case TO_BOOL_ALWAYS_TRUE: - return 1; - case UNARY_INVERT: - return 1; - case _GUARD_BOTH_INT: - return 2; - case _BINARY_OP_MULTIPLY_INT: - return 2; - case _BINARY_OP_ADD_INT: - return 2; - case _BINARY_OP_SUBTRACT_INT: - return 2; - case BINARY_OP_MULTIPLY_INT: - return 2; - case BINARY_OP_ADD_INT: - return 2; - case BINARY_OP_SUBTRACT_INT: - return 2; - case _GUARD_BOTH_FLOAT: - return 2; - case _BINARY_OP_MULTIPLY_FLOAT: - return 2; - case _BINARY_OP_ADD_FLOAT: - return 2; - case _BINARY_OP_SUBTRACT_FLOAT: - return 2; - case BINARY_OP_MULTIPLY_FLOAT: - return 2; - case BINARY_OP_ADD_FLOAT: - return 2; - case BINARY_OP_SUBTRACT_FLOAT: - return 2; - case _GUARD_BOTH_UNICODE: - return 2; - case _BINARY_OP_ADD_UNICODE: - return 2; - case BINARY_OP_ADD_UNICODE: - return 2; - case _BINARY_OP_INPLACE_ADD_UNICODE: - return 2; - case BINARY_OP_INPLACE_ADD_UNICODE: - return 2; - case _SPECIALIZE_BINARY_SUBSCR: - return 2; - case _BINARY_SUBSCR: - return 2; - case BINARY_SUBSCR: - return 2; - case BINARY_SLICE: - return 3; - case STORE_SLICE: - return 4; - case BINARY_SUBSCR_LIST_INT: - return 2; - case BINARY_SUBSCR_STR_INT: - return 2; - case BINARY_SUBSCR_TUPLE_INT: - return 2; - case BINARY_SUBSCR_DICT: - return 2; - case BINARY_SUBSCR_GETITEM: - return 2; - case LIST_APPEND: - return (oparg-1) + 2; - case SET_ADD: - return (oparg-1) + 2; - case _SPECIALIZE_STORE_SUBSCR: - return 2; - case _STORE_SUBSCR: - return 3; - case STORE_SUBSCR: - return 3; - case STORE_SUBSCR_LIST_INT: - return 3; - case STORE_SUBSCR_DICT: - return 3; - case DELETE_SUBSCR: - return 2; - case CALL_INTRINSIC_1: - return 1; - case CALL_INTRINSIC_2: - return 2; - case RAISE_VARARGS: - return oparg; - case INTERPRETER_EXIT: - return 1; - case _POP_FRAME: - return 1; - case RETURN_VALUE: - return 1; - case INSTRUMENTED_RETURN_VALUE: - return 1; - case RETURN_CONST: - return 0; - case INSTRUMENTED_RETURN_CONST: - return 0; - case GET_AITER: - return 1; - case GET_ANEXT: - return 1; - case GET_AWAITABLE: - return 1; - case _SPECIALIZE_SEND: - return 2; - case _SEND: - return 2; - case SEND: - return 2; - case SEND_GEN: - return 2; - case INSTRUMENTED_YIELD_VALUE: - return 1; - case YIELD_VALUE: - return 1; - case POP_EXCEPT: - return 1; - case RERAISE: - return oparg + 1; - case END_ASYNC_FOR: - return 2; - case CLEANUP_THROW: - return 3; - case LOAD_ASSERTION_ERROR: - return 0; - case LOAD_BUILD_CLASS: - return 0; - case STORE_NAME: - return 1; - case DELETE_NAME: - return 0; - case _SPECIALIZE_UNPACK_SEQUENCE: - return 1; - case _UNPACK_SEQUENCE: - return 1; - case UNPACK_SEQUENCE: - return 1; - case UNPACK_SEQUENCE_TWO_TUPLE: - return 1; - case UNPACK_SEQUENCE_TUPLE: - return 1; - case UNPACK_SEQUENCE_LIST: - return 1; - case UNPACK_EX: - return 1; - case _SPECIALIZE_STORE_ATTR: - return 1; - case _STORE_ATTR: - return 2; - case STORE_ATTR: - return 2; - case DELETE_ATTR: - return 1; - case STORE_GLOBAL: - return 1; - case DELETE_GLOBAL: - return 0; - case LOAD_LOCALS: - return 0; - case LOAD_FROM_DICT_OR_GLOBALS: - return 1; - case LOAD_NAME: - return 0; - case _SPECIALIZE_LOAD_GLOBAL: - return 0; - case _LOAD_GLOBAL: - return 0; - case LOAD_GLOBAL: - return 0; - case _GUARD_GLOBALS_VERSION: - return 0; - case _GUARD_BUILTINS_VERSION: - return 0; - case _LOAD_GLOBAL_MODULE: - return 0; - case _LOAD_GLOBAL_BUILTINS: - return 0; - case LOAD_GLOBAL_MODULE: - return 0; - case LOAD_GLOBAL_BUILTIN: - return 0; - case DELETE_FAST: - return 0; - case MAKE_CELL: - return 0; - case DELETE_DEREF: - return 0; - case LOAD_FROM_DICT_OR_DEREF: - return 1; - case LOAD_DEREF: - return 0; - case STORE_DEREF: - return 1; - case COPY_FREE_VARS: - return 0; - case BUILD_STRING: - return oparg; - case BUILD_TUPLE: - return oparg; - case BUILD_LIST: - return oparg; - case LIST_EXTEND: - return (oparg-1) + 2; - case SET_UPDATE: - return (oparg-1) + 2; - case BUILD_SET: - return oparg; - case BUILD_MAP: - return oparg*2; - case SETUP_ANNOTATIONS: - return 0; - case BUILD_CONST_KEY_MAP: - return oparg + 1; - case DICT_UPDATE: - return (oparg - 1) + 2; - case DICT_MERGE: - return (oparg - 1) + 5; - case MAP_ADD: - return (oparg - 1) + 3; - case INSTRUMENTED_LOAD_SUPER_ATTR: - return 3; - case _SPECIALIZE_LOAD_SUPER_ATTR: - return 3; - case _LOAD_SUPER_ATTR: - return 3; - case LOAD_SUPER_ATTR: - return 3; - case LOAD_SUPER_METHOD: - return 3; - case LOAD_ZERO_SUPER_METHOD: - return 3; - case LOAD_ZERO_SUPER_ATTR: - return 3; - case LOAD_SUPER_ATTR_ATTR: - return 3; - case LOAD_SUPER_ATTR_METHOD: - return 3; - case _SPECIALIZE_LOAD_ATTR: - return 1; - case _LOAD_ATTR: - return 1; - case LOAD_ATTR: - return 1; - case LOAD_METHOD: - return 1; - case _GUARD_TYPE_VERSION: - return 1; - case _CHECK_MANAGED_OBJECT_HAS_VALUES: - return 1; - case _LOAD_ATTR_INSTANCE_VALUE: - return 1; - case LOAD_ATTR_INSTANCE_VALUE: - return 1; - case _CHECK_ATTR_MODULE: - return 1; - case _LOAD_ATTR_MODULE: - return 1; - case LOAD_ATTR_MODULE: - return 1; - case _CHECK_ATTR_WITH_HINT: - return 1; - case _LOAD_ATTR_WITH_HINT: - return 1; - case LOAD_ATTR_WITH_HINT: - return 1; - case _LOAD_ATTR_SLOT: - return 1; - case LOAD_ATTR_SLOT: - return 1; - case _CHECK_ATTR_CLASS: - return 1; - case _LOAD_ATTR_CLASS: - return 1; - case LOAD_ATTR_CLASS: - return 1; - case LOAD_ATTR_PROPERTY: - return 1; - case LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN: - return 1; - case _GUARD_DORV_VALUES: - return 1; - case _STORE_ATTR_INSTANCE_VALUE: - return 2; - case STORE_ATTR_INSTANCE_VALUE: - return 2; - case STORE_ATTR_WITH_HINT: - return 2; - case _STORE_ATTR_SLOT: - return 2; - case STORE_ATTR_SLOT: - return 2; - case _SPECIALIZE_COMPARE_OP: - return 2; - case _COMPARE_OP: - return 2; - case COMPARE_OP: - return 2; - case COMPARE_OP_FLOAT: - return 2; - case COMPARE_OP_INT: - return 2; - case COMPARE_OP_STR: - return 2; - case IS_OP: - return 2; - case CONTAINS_OP: - return 2; - case CHECK_EG_MATCH: - return 2; - case CHECK_EXC_MATCH: - return 2; - case IMPORT_NAME: - return 2; - case IMPORT_FROM: - return 1; - case JUMP_FORWARD: - return 0; - case JUMP_BACKWARD: - return 0; - case JUMP: - return 0; - case JUMP_NO_INTERRUPT: - return 0; - case ENTER_EXECUTOR: - return 0; - case _POP_JUMP_IF_FALSE: - return 1; - case _POP_JUMP_IF_TRUE: - return 1; - case _IS_NONE: - return 1; - case POP_JUMP_IF_TRUE: - return 1; - case POP_JUMP_IF_FALSE: - return 1; - case POP_JUMP_IF_NONE: - return 1; - case POP_JUMP_IF_NOT_NONE: - return 1; - case JUMP_BACKWARD_NO_INTERRUPT: - return 0; - case GET_LEN: - return 1; - case MATCH_CLASS: - return 3; - case MATCH_MAPPING: - return 1; - case MATCH_SEQUENCE: - return 1; - case MATCH_KEYS: - return 2; - case GET_ITER: - return 1; - case GET_YIELD_FROM_ITER: - return 1; - case _SPECIALIZE_FOR_ITER: - return 1; - case _FOR_ITER: - return 1; - case _FOR_ITER_TIER_TWO: - return 1; - case FOR_ITER: - return 1; - case INSTRUMENTED_FOR_ITER: - return 0; - case _ITER_CHECK_LIST: - return 1; - case _ITER_JUMP_LIST: - return 1; - case _GUARD_NOT_EXHAUSTED_LIST: - return 1; - case _ITER_NEXT_LIST: - return 1; - case FOR_ITER_LIST: - return 1; - case _ITER_CHECK_TUPLE: - return 1; - case _ITER_JUMP_TUPLE: - return 1; - case _GUARD_NOT_EXHAUSTED_TUPLE: - return 1; - case _ITER_NEXT_TUPLE: - return 1; - case FOR_ITER_TUPLE: - return 1; - case _ITER_CHECK_RANGE: - return 1; - case _ITER_JUMP_RANGE: - return 1; - case _GUARD_NOT_EXHAUSTED_RANGE: - return 1; - case _ITER_NEXT_RANGE: - return 1; - case FOR_ITER_RANGE: - return 1; - case FOR_ITER_GEN: - return 1; - case BEFORE_ASYNC_WITH: - return 1; - case BEFORE_WITH: - return 1; - case WITH_EXCEPT_START: - return 4; - case SETUP_FINALLY: - return 0; - case SETUP_CLEANUP: - return 0; - case SETUP_WITH: - return 0; - case POP_BLOCK: - return 0; - case PUSH_EXC_INFO: - return 1; - case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: - return 1; - case _GUARD_KEYS_VERSION: - return 1; - case _LOAD_ATTR_METHOD_WITH_VALUES: - return 1; - case LOAD_ATTR_METHOD_WITH_VALUES: - return 1; - case _LOAD_ATTR_METHOD_NO_DICT: - return 1; - case LOAD_ATTR_METHOD_NO_DICT: - return 1; - case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: - return 1; - case LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: - return 1; - case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: - return 1; - case LOAD_ATTR_NONDESCRIPTOR_NO_DICT: - return 1; - case _CHECK_ATTR_METHOD_LAZY_DICT: - return 1; - case _LOAD_ATTR_METHOD_LAZY_DICT: - return 1; - case LOAD_ATTR_METHOD_LAZY_DICT: - return 1; - case INSTRUMENTED_CALL: - return 0; - case _SPECIALIZE_CALL: - return oparg + 2; - case _CALL: - return oparg + 2; - case CALL: - return oparg + 2; - case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: - return oparg + 2; - case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: - return oparg + 2; - case _CHECK_PEP_523: - return 0; - case _CHECK_FUNCTION_EXACT_ARGS: - return oparg + 2; - case _CHECK_STACK_SPACE: - return oparg + 2; - case _INIT_CALL_PY_EXACT_ARGS: - return oparg + 2; - case _PUSH_FRAME: - return 1; - case CALL_BOUND_METHOD_EXACT_ARGS: - return oparg + 2; - case CALL_PY_EXACT_ARGS: - return oparg + 2; - case CALL_PY_WITH_DEFAULTS: - return oparg + 2; - case CALL_TYPE_1: - return oparg + 2; - case CALL_STR_1: - return oparg + 2; - case CALL_TUPLE_1: - return oparg + 2; - case CALL_ALLOC_AND_ENTER_INIT: - return oparg + 2; - case EXIT_INIT_CHECK: - return 1; - case CALL_BUILTIN_CLASS: - return oparg + 2; - case CALL_BUILTIN_O: - return oparg + 2; - case CALL_BUILTIN_FAST: - return oparg + 2; - case CALL_BUILTIN_FAST_WITH_KEYWORDS: - return oparg + 2; - case CALL_LEN: - return oparg + 2; - case CALL_ISINSTANCE: - return oparg + 2; - case CALL_LIST_APPEND: - return oparg + 2; - case CALL_METHOD_DESCRIPTOR_O: - return oparg + 2; - case CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: - return oparg + 2; - case CALL_METHOD_DESCRIPTOR_NOARGS: - return oparg + 2; - case CALL_METHOD_DESCRIPTOR_FAST: - return oparg + 2; - case INSTRUMENTED_CALL_KW: - return 0; - case CALL_KW: - return oparg + 3; - case INSTRUMENTED_CALL_FUNCTION_EX: - return 0; - case CALL_FUNCTION_EX: - return ((oparg & 1) ? 1 : 0) + 3; - case MAKE_FUNCTION: - return 1; - case SET_FUNCTION_ATTRIBUTE: - return 2; - case RETURN_GENERATOR: - return 0; - case BUILD_SLICE: - return ((oparg == 3) ? 1 : 0) + 2; - case CONVERT_VALUE: - return 1; - case FORMAT_SIMPLE: - return 1; - case FORMAT_WITH_SPEC: - return 2; - case COPY: - return (oparg-1) + 1; - case _SPECIALIZE_BINARY_OP: - return 2; - case _BINARY_OP: - return 2; - case BINARY_OP: - return 2; - case SWAP: - return (oparg-2) + 2; - case INSTRUMENTED_INSTRUCTION: - return 0; - case INSTRUMENTED_JUMP_FORWARD: - return 0; - case INSTRUMENTED_JUMP_BACKWARD: - return 0; - case INSTRUMENTED_POP_JUMP_IF_TRUE: - return 0; - case INSTRUMENTED_POP_JUMP_IF_FALSE: - return 0; - case INSTRUMENTED_POP_JUMP_IF_NONE: - return 0; - case INSTRUMENTED_POP_JUMP_IF_NOT_NONE: - return 0; - case EXTENDED_ARG: - return 0; - case CACHE: - return 0; - case RESERVED: - return 0; - case _GUARD_IS_TRUE_POP: - return 1; - case _GUARD_IS_FALSE_POP: - return 1; - case _GUARD_IS_NONE_POP: - return 1; - case _GUARD_IS_NOT_NONE_POP: - return 1; - case _JUMP_TO_TOP: - return 0; - case _SET_IP: - return 0; - case _SAVE_RETURN_OFFSET: - return 0; - case _EXIT_TRACE: - return 0; - case _INSERT: - return oparg + 1; - case _CHECK_VALIDITY: - return 0; - default: - return -1; - } -} -#endif // NEED_OPCODE_METADATA - -extern int _PyOpcode_num_pushed(int opcode, int oparg, bool jump); -#ifdef NEED_OPCODE_METADATA -int _PyOpcode_num_pushed(int opcode, int oparg, bool jump) { - switch(opcode) { - case NOP: - return 0; - case RESUME: - return 0; - case RESUME_CHECK: - return 0; - case INSTRUMENTED_RESUME: - return 0; - case LOAD_CLOSURE: - return 1; - case LOAD_FAST_CHECK: - return 1; - case LOAD_FAST: - return 1; - case LOAD_FAST_AND_CLEAR: - return 1; - case LOAD_FAST_LOAD_FAST: - return 2; - case LOAD_CONST: - return 1; - case STORE_FAST: - return 0; - case STORE_FAST_MAYBE_NULL: - return 0; - case STORE_FAST_LOAD_FAST: - return 1; - case STORE_FAST_STORE_FAST: - return 0; - case POP_TOP: - return 0; - case PUSH_NULL: - return 1; - case END_FOR: - return 0; - case INSTRUMENTED_END_FOR: - return 0; - case END_SEND: - return 1; - case INSTRUMENTED_END_SEND: - return 1; - case UNARY_NEGATIVE: - return 1; - case UNARY_NOT: - return 1; - case _SPECIALIZE_TO_BOOL: - return 1; - case _TO_BOOL: - return 1; - case TO_BOOL: - return 1; - case TO_BOOL_BOOL: - return 1; - case TO_BOOL_INT: - return 1; - case TO_BOOL_LIST: - return 1; - case TO_BOOL_NONE: - return 1; - case TO_BOOL_STR: - return 1; - case TO_BOOL_ALWAYS_TRUE: - return 1; - case UNARY_INVERT: - return 1; - case _GUARD_BOTH_INT: - return 2; - case _BINARY_OP_MULTIPLY_INT: - return 1; - case _BINARY_OP_ADD_INT: - return 1; - case _BINARY_OP_SUBTRACT_INT: - return 1; - case BINARY_OP_MULTIPLY_INT: - return 1; - case BINARY_OP_ADD_INT: - return 1; - case BINARY_OP_SUBTRACT_INT: - return 1; - case _GUARD_BOTH_FLOAT: - return 2; - case _BINARY_OP_MULTIPLY_FLOAT: - return 1; - case _BINARY_OP_ADD_FLOAT: - return 1; - case _BINARY_OP_SUBTRACT_FLOAT: - return 1; - case BINARY_OP_MULTIPLY_FLOAT: - return 1; - case BINARY_OP_ADD_FLOAT: - return 1; - case BINARY_OP_SUBTRACT_FLOAT: - return 1; - case _GUARD_BOTH_UNICODE: - return 2; - case _BINARY_OP_ADD_UNICODE: - return 1; - case BINARY_OP_ADD_UNICODE: - return 1; - case _BINARY_OP_INPLACE_ADD_UNICODE: - return 0; - case BINARY_OP_INPLACE_ADD_UNICODE: - return 0; - case _SPECIALIZE_BINARY_SUBSCR: - return 2; - case _BINARY_SUBSCR: - return 1; - case BINARY_SUBSCR: - return 1; - case BINARY_SLICE: - return 1; - case STORE_SLICE: - return 0; - case BINARY_SUBSCR_LIST_INT: - return 1; - case BINARY_SUBSCR_STR_INT: - return 1; - case BINARY_SUBSCR_TUPLE_INT: - return 1; - case BINARY_SUBSCR_DICT: - return 1; - case BINARY_SUBSCR_GETITEM: - return 1; - case LIST_APPEND: - return (oparg-1) + 1; - case SET_ADD: - return (oparg-1) + 1; - case _SPECIALIZE_STORE_SUBSCR: - return 2; - case _STORE_SUBSCR: - return 0; - case STORE_SUBSCR: - return 0; - case STORE_SUBSCR_LIST_INT: - return 0; - case STORE_SUBSCR_DICT: - return 0; - case DELETE_SUBSCR: - return 0; - case CALL_INTRINSIC_1: - return 1; - case CALL_INTRINSIC_2: - return 1; - case RAISE_VARARGS: - return 0; - case INTERPRETER_EXIT: - return 0; - case _POP_FRAME: - return 0; - case RETURN_VALUE: - return 0; - case INSTRUMENTED_RETURN_VALUE: - return 0; - case RETURN_CONST: - return 0; - case INSTRUMENTED_RETURN_CONST: - return 0; - case GET_AITER: - return 1; - case GET_ANEXT: - return 2; - case GET_AWAITABLE: - return 1; - case _SPECIALIZE_SEND: - return 2; - case _SEND: - return 2; - case SEND: - return 2; - case SEND_GEN: - return 2; - case INSTRUMENTED_YIELD_VALUE: - return 1; - case YIELD_VALUE: - return 1; - case POP_EXCEPT: - return 0; - case RERAISE: - return oparg; - case END_ASYNC_FOR: - return 0; - case CLEANUP_THROW: - return 2; - case LOAD_ASSERTION_ERROR: - return 1; - case LOAD_BUILD_CLASS: - return 1; - case STORE_NAME: - return 0; - case DELETE_NAME: - return 0; - case _SPECIALIZE_UNPACK_SEQUENCE: - return 1; - case _UNPACK_SEQUENCE: - return oparg; - case UNPACK_SEQUENCE: - return oparg; - case UNPACK_SEQUENCE_TWO_TUPLE: - return oparg; - case UNPACK_SEQUENCE_TUPLE: - return oparg; - case UNPACK_SEQUENCE_LIST: - return oparg; - case UNPACK_EX: - return (oparg & 0xFF) + (oparg >> 8) + 1; - case _SPECIALIZE_STORE_ATTR: - return 1; - case _STORE_ATTR: - return 0; - case STORE_ATTR: - return 0; - case DELETE_ATTR: - return 0; - case STORE_GLOBAL: - return 0; - case DELETE_GLOBAL: - return 0; - case LOAD_LOCALS: - return 1; - case LOAD_FROM_DICT_OR_GLOBALS: - return 1; - case LOAD_NAME: - return 1; - case _SPECIALIZE_LOAD_GLOBAL: - return 0; - case _LOAD_GLOBAL: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_GLOBAL: - return (oparg & 1 ? 1 : 0) + 1; - case _GUARD_GLOBALS_VERSION: - return 0; - case _GUARD_BUILTINS_VERSION: - return 0; - case _LOAD_GLOBAL_MODULE: - return ((oparg & 1) ? 1 : 0) + 1; - case _LOAD_GLOBAL_BUILTINS: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_GLOBAL_MODULE: - return (oparg & 1 ? 1 : 0) + 1; - case LOAD_GLOBAL_BUILTIN: - return (oparg & 1 ? 1 : 0) + 1; - case DELETE_FAST: - return 0; - case MAKE_CELL: - return 0; - case DELETE_DEREF: - return 0; - case LOAD_FROM_DICT_OR_DEREF: - return 1; - case LOAD_DEREF: - return 1; - case STORE_DEREF: - return 0; - case COPY_FREE_VARS: - return 0; - case BUILD_STRING: - return 1; - case BUILD_TUPLE: - return 1; - case BUILD_LIST: - return 1; - case LIST_EXTEND: - return (oparg-1) + 1; - case SET_UPDATE: - return (oparg-1) + 1; - case BUILD_SET: - return 1; - case BUILD_MAP: - return 1; - case SETUP_ANNOTATIONS: - return 0; - case BUILD_CONST_KEY_MAP: - return 1; - case DICT_UPDATE: - return (oparg - 1) + 1; - case DICT_MERGE: - return (oparg - 1) + 4; - case MAP_ADD: - return (oparg - 1) + 1; - case INSTRUMENTED_LOAD_SUPER_ATTR: - return ((oparg & 1) ? 1 : 0) + 1; - case _SPECIALIZE_LOAD_SUPER_ATTR: - return 3; - case _LOAD_SUPER_ATTR: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_SUPER_ATTR: - return (oparg & 1 ? 1 : 0) + 1; - case LOAD_SUPER_METHOD: - return (oparg & 1 ? 1 : 0) + 1; - case LOAD_ZERO_SUPER_METHOD: - return (oparg & 1 ? 1 : 0) + 1; - case LOAD_ZERO_SUPER_ATTR: - return (oparg & 1 ? 1 : 0) + 1; - case LOAD_SUPER_ATTR_ATTR: - return 1; - case LOAD_SUPER_ATTR_METHOD: - return 2; - case _SPECIALIZE_LOAD_ATTR: - return 1; - case _LOAD_ATTR: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_ATTR: - return (oparg & 1 ? 1 : 0) + 1; - case LOAD_METHOD: - return (oparg & 1 ? 1 : 0) + 1; - case _GUARD_TYPE_VERSION: - return 1; - case _CHECK_MANAGED_OBJECT_HAS_VALUES: - return 1; - case _LOAD_ATTR_INSTANCE_VALUE: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_ATTR_INSTANCE_VALUE: - return (oparg & 1 ? 1 : 0) + 1; - case _CHECK_ATTR_MODULE: - return 1; - case _LOAD_ATTR_MODULE: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_ATTR_MODULE: - return (oparg & 1 ? 1 : 0) + 1; - case _CHECK_ATTR_WITH_HINT: - return 1; - case _LOAD_ATTR_WITH_HINT: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_ATTR_WITH_HINT: - return (oparg & 1 ? 1 : 0) + 1; - case _LOAD_ATTR_SLOT: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_ATTR_SLOT: - return (oparg & 1 ? 1 : 0) + 1; - case _CHECK_ATTR_CLASS: - return 1; - case _LOAD_ATTR_CLASS: - return ((oparg & 1) ? 1 : 0) + 1; - case LOAD_ATTR_CLASS: - return (oparg & 1 ? 1 : 0) + 1; - case LOAD_ATTR_PROPERTY: - return 1; - case LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN: - return 1; - case _GUARD_DORV_VALUES: - return 1; - case _STORE_ATTR_INSTANCE_VALUE: - return 0; - case STORE_ATTR_INSTANCE_VALUE: - return 0; - case STORE_ATTR_WITH_HINT: - return 0; - case _STORE_ATTR_SLOT: - return 0; - case STORE_ATTR_SLOT: - return 0; - case _SPECIALIZE_COMPARE_OP: - return 2; - case _COMPARE_OP: - return 1; - case COMPARE_OP: - return 1; - case COMPARE_OP_FLOAT: - return 1; - case COMPARE_OP_INT: - return 1; - case COMPARE_OP_STR: - return 1; - case IS_OP: - return 1; - case CONTAINS_OP: - return 1; - case CHECK_EG_MATCH: - return 2; - case CHECK_EXC_MATCH: - return 2; - case IMPORT_NAME: - return 1; - case IMPORT_FROM: - return 2; - case JUMP_FORWARD: - return 0; - case JUMP_BACKWARD: - return 0; - case JUMP: - return 0; - case JUMP_NO_INTERRUPT: - return 0; - case ENTER_EXECUTOR: - return 0; - case _POP_JUMP_IF_FALSE: - return 0; - case _POP_JUMP_IF_TRUE: - return 0; - case _IS_NONE: - return 1; - case POP_JUMP_IF_TRUE: - return 0; - case POP_JUMP_IF_FALSE: - return 0; - case POP_JUMP_IF_NONE: - return 0; - case POP_JUMP_IF_NOT_NONE: - return 0; - case JUMP_BACKWARD_NO_INTERRUPT: - return 0; - case GET_LEN: - return 2; - case MATCH_CLASS: - return 1; - case MATCH_MAPPING: - return 2; - case MATCH_SEQUENCE: - return 2; - case MATCH_KEYS: - return 3; - case GET_ITER: - return 1; - case GET_YIELD_FROM_ITER: - return 1; - case _SPECIALIZE_FOR_ITER: - return 1; - case _FOR_ITER: - return 2; - case _FOR_ITER_TIER_TWO: - return 2; - case FOR_ITER: - return 2; - case INSTRUMENTED_FOR_ITER: - return 0; - case _ITER_CHECK_LIST: - return 1; - case _ITER_JUMP_LIST: - return 1; - case _GUARD_NOT_EXHAUSTED_LIST: - return 1; - case _ITER_NEXT_LIST: - return 2; - case FOR_ITER_LIST: - return 2; - case _ITER_CHECK_TUPLE: - return 1; - case _ITER_JUMP_TUPLE: - return 1; - case _GUARD_NOT_EXHAUSTED_TUPLE: - return 1; - case _ITER_NEXT_TUPLE: - return 2; - case FOR_ITER_TUPLE: - return 2; - case _ITER_CHECK_RANGE: - return 1; - case _ITER_JUMP_RANGE: - return 1; - case _GUARD_NOT_EXHAUSTED_RANGE: - return 1; - case _ITER_NEXT_RANGE: - return 2; - case FOR_ITER_RANGE: - return 2; - case FOR_ITER_GEN: - return 2; - case BEFORE_ASYNC_WITH: - return 2; - case BEFORE_WITH: - return 2; - case WITH_EXCEPT_START: - return 5; - case SETUP_FINALLY: - return 0; - case SETUP_CLEANUP: - return 0; - case SETUP_WITH: - return 0; - case POP_BLOCK: - return 0; - case PUSH_EXC_INFO: - return 2; - case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: - return 1; - case _GUARD_KEYS_VERSION: - return 1; - case _LOAD_ATTR_METHOD_WITH_VALUES: - return 2; - case LOAD_ATTR_METHOD_WITH_VALUES: - return 2; - case _LOAD_ATTR_METHOD_NO_DICT: - return 2; - case LOAD_ATTR_METHOD_NO_DICT: - return 2; - case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: - return 1; - case LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: - return 1; - case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: - return 1; - case LOAD_ATTR_NONDESCRIPTOR_NO_DICT: - return 1; - case _CHECK_ATTR_METHOD_LAZY_DICT: - return 1; - case _LOAD_ATTR_METHOD_LAZY_DICT: - return 2; - case LOAD_ATTR_METHOD_LAZY_DICT: - return 2; - case INSTRUMENTED_CALL: - return 0; - case _SPECIALIZE_CALL: - return oparg + 2; - case _CALL: - return 1; - case CALL: - return 1; - case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: - return oparg + 2; - case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: - return oparg + 2; - case _CHECK_PEP_523: - return 0; - case _CHECK_FUNCTION_EXACT_ARGS: - return oparg + 2; - case _CHECK_STACK_SPACE: - return oparg + 2; - case _INIT_CALL_PY_EXACT_ARGS: - return 1; - case _PUSH_FRAME: - return 0; - case CALL_BOUND_METHOD_EXACT_ARGS: - return 0; - case CALL_PY_EXACT_ARGS: - return 0; - case CALL_PY_WITH_DEFAULTS: - return 1; - case CALL_TYPE_1: - return 1; - case CALL_STR_1: - return 1; - case CALL_TUPLE_1: - return 1; - case CALL_ALLOC_AND_ENTER_INIT: - return 1; - case EXIT_INIT_CHECK: - return 0; - case CALL_BUILTIN_CLASS: - return 1; - case CALL_BUILTIN_O: - return 1; - case CALL_BUILTIN_FAST: - return 1; - case CALL_BUILTIN_FAST_WITH_KEYWORDS: - return 1; - case CALL_LEN: - return 1; - case CALL_ISINSTANCE: - return 1; - case CALL_LIST_APPEND: - return 1; - case CALL_METHOD_DESCRIPTOR_O: - return 1; - case CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: - return 1; - case CALL_METHOD_DESCRIPTOR_NOARGS: - return 1; - case CALL_METHOD_DESCRIPTOR_FAST: - return 1; - case INSTRUMENTED_CALL_KW: - return 0; - case CALL_KW: - return 1; - case INSTRUMENTED_CALL_FUNCTION_EX: - return 0; - case CALL_FUNCTION_EX: - return 1; - case MAKE_FUNCTION: - return 1; - case SET_FUNCTION_ATTRIBUTE: - return 1; - case RETURN_GENERATOR: - return 0; - case BUILD_SLICE: - return 1; - case CONVERT_VALUE: - return 1; - case FORMAT_SIMPLE: - return 1; - case FORMAT_WITH_SPEC: - return 1; - case COPY: - return (oparg-1) + 2; - case _SPECIALIZE_BINARY_OP: - return 2; - case _BINARY_OP: - return 1; - case BINARY_OP: - return 1; - case SWAP: - return (oparg-2) + 2; - case INSTRUMENTED_INSTRUCTION: - return 0; - case INSTRUMENTED_JUMP_FORWARD: - return 0; - case INSTRUMENTED_JUMP_BACKWARD: - return 0; - case INSTRUMENTED_POP_JUMP_IF_TRUE: - return 0; - case INSTRUMENTED_POP_JUMP_IF_FALSE: - return 0; - case INSTRUMENTED_POP_JUMP_IF_NONE: - return 0; - case INSTRUMENTED_POP_JUMP_IF_NOT_NONE: - return 0; - case EXTENDED_ARG: - return 0; - case CACHE: - return 0; - case RESERVED: - return 0; - case _GUARD_IS_TRUE_POP: - return 0; - case _GUARD_IS_FALSE_POP: - return 0; - case _GUARD_IS_NONE_POP: - return 0; - case _GUARD_IS_NOT_NONE_POP: - return 0; - case _JUMP_TO_TOP: - return 0; - case _SET_IP: - return 0; - case _SAVE_RETURN_OFFSET: - return 0; - case _EXIT_TRACE: - return 0; - case _INSERT: - return oparg + 1; - case _CHECK_VALIDITY: - return 0; - default: - return -1; - } -} -#endif // NEED_OPCODE_METADATA - enum InstructionFormat { - INSTR_FMT_IB, - INSTR_FMT_IBC, - INSTR_FMT_IBC0, - INSTR_FMT_IBC00, - INSTR_FMT_IBC000, - INSTR_FMT_IBC0000000, - INSTR_FMT_IBC00000000, - INSTR_FMT_IX, - INSTR_FMT_IXC, - INSTR_FMT_IXC0, - INSTR_FMT_IXC00, - INSTR_FMT_IXC000, + INSTR_FMT_IB = 1, + INSTR_FMT_IBC = 2, + INSTR_FMT_IBC00 = 3, + INSTR_FMT_IBC000 = 4, + INSTR_FMT_IBC00000000 = 5, + INSTR_FMT_IX = 6, + INSTR_FMT_IXC = 7, + INSTR_FMT_IXC00 = 8, + INSTR_FMT_IXC000 = 9, }; -#define IS_VALID_OPCODE(OP) \ - (((OP) >= 0) && ((OP) < OPCODE_METADATA_SIZE) && \ - (_PyOpcode_opcode_metadata[(OP)].valid_entry)) - -#define HAS_ARG_FLAG (1) -#define HAS_CONST_FLAG (2) -#define HAS_NAME_FLAG (4) -#define HAS_JUMP_FLAG (8) -#define HAS_FREE_FLAG (16) -#define HAS_LOCAL_FLAG (32) -#define HAS_EVAL_BREAK_FLAG (64) -#define HAS_DEOPT_FLAG (128) -#define HAS_ERROR_FLAG (256) -#define HAS_ESCAPES_FLAG (512) -#define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) -#define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) -#define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) -#define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) -#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) -#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) -#define OPCODE_HAS_EVAL_BREAK(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_EVAL_BREAK_FLAG)) -#define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) -#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) -#define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) - -struct opcode_metadata { - bool valid_entry; - enum InstructionFormat instr_format; - int flags; +const uint8_t _PyOpcode_Deopt[256] = { + [NOP] = NOP, + [RESUME] = RESUME, + [RESUME_CHECK] = RESUME, + [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, + [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, + [LOAD_FAST] = LOAD_FAST, + [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, + [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, + [LOAD_CONST] = LOAD_CONST, + [STORE_FAST] = STORE_FAST, + [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, + [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, + [POP_TOP] = POP_TOP, + [PUSH_NULL] = PUSH_NULL, + [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, + [END_SEND] = END_SEND, + [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, + [UNARY_NEGATIVE] = UNARY_NEGATIVE, + [UNARY_NOT] = UNARY_NOT, + [TO_BOOL_BOOL] = TO_BOOL, + [TO_BOOL_INT] = TO_BOOL, + [TO_BOOL_LIST] = TO_BOOL, + [TO_BOOL_NONE] = TO_BOOL, + [TO_BOOL_STR] = TO_BOOL, + [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, + [UNARY_INVERT] = UNARY_INVERT, + [BINARY_SLICE] = BINARY_SLICE, + [STORE_SLICE] = STORE_SLICE, + [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, + [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, + [LIST_APPEND] = LIST_APPEND, + [SET_ADD] = SET_ADD, + [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, + [STORE_SUBSCR_DICT] = STORE_SUBSCR, + [DELETE_SUBSCR] = DELETE_SUBSCR, + [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, + [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, + [RAISE_VARARGS] = RAISE_VARARGS, + [INTERPRETER_EXIT] = INTERPRETER_EXIT, + [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, + [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST, + [GET_AITER] = GET_AITER, + [GET_ANEXT] = GET_ANEXT, + [GET_AWAITABLE] = GET_AWAITABLE, + [SEND_GEN] = SEND, + [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, + [YIELD_VALUE] = YIELD_VALUE, + [POP_EXCEPT] = POP_EXCEPT, + [RERAISE] = RERAISE, + [END_ASYNC_FOR] = END_ASYNC_FOR, + [CLEANUP_THROW] = CLEANUP_THROW, + [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, + [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, + [STORE_NAME] = STORE_NAME, + [DELETE_NAME] = DELETE_NAME, + [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, + [UNPACK_EX] = UNPACK_EX, + [DELETE_ATTR] = DELETE_ATTR, + [STORE_GLOBAL] = STORE_GLOBAL, + [DELETE_GLOBAL] = DELETE_GLOBAL, + [LOAD_LOCALS] = LOAD_LOCALS, + [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, + [LOAD_NAME] = LOAD_NAME, + [DELETE_FAST] = DELETE_FAST, + [MAKE_CELL] = MAKE_CELL, + [DELETE_DEREF] = DELETE_DEREF, + [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, + [LOAD_DEREF] = LOAD_DEREF, + [STORE_DEREF] = STORE_DEREF, + [COPY_FREE_VARS] = COPY_FREE_VARS, + [BUILD_STRING] = BUILD_STRING, + [BUILD_TUPLE] = BUILD_TUPLE, + [BUILD_LIST] = BUILD_LIST, + [LIST_EXTEND] = LIST_EXTEND, + [SET_UPDATE] = SET_UPDATE, + [BUILD_SET] = BUILD_SET, + [BUILD_MAP] = BUILD_MAP, + [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, + [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, + [DICT_UPDATE] = DICT_UPDATE, + [DICT_MERGE] = DICT_MERGE, + [MAP_ADD] = MAP_ADD, + [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, + [LOAD_ATTR_PROPERTY] = LOAD_ATTR, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, + [STORE_ATTR_WITH_HINT] = STORE_ATTR, + [COMPARE_OP_FLOAT] = COMPARE_OP, + [COMPARE_OP_INT] = COMPARE_OP, + [COMPARE_OP_STR] = COMPARE_OP, + [IS_OP] = IS_OP, + [CONTAINS_OP] = CONTAINS_OP, + [CHECK_EG_MATCH] = CHECK_EG_MATCH, + [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, + [IMPORT_NAME] = IMPORT_NAME, + [IMPORT_FROM] = IMPORT_FROM, + [JUMP_FORWARD] = JUMP_FORWARD, + [JUMP_BACKWARD] = JUMP_BACKWARD, + [ENTER_EXECUTOR] = ENTER_EXECUTOR, + [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, + [GET_LEN] = GET_LEN, + [MATCH_CLASS] = MATCH_CLASS, + [MATCH_MAPPING] = MATCH_MAPPING, + [MATCH_SEQUENCE] = MATCH_SEQUENCE, + [MATCH_KEYS] = MATCH_KEYS, + [GET_ITER] = GET_ITER, + [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, + [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, + [FOR_ITER_GEN] = FOR_ITER, + [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, + [BEFORE_WITH] = BEFORE_WITH, + [WITH_EXCEPT_START] = WITH_EXCEPT_START, + [PUSH_EXC_INFO] = PUSH_EXC_INFO, + [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, + [CALL_PY_WITH_DEFAULTS] = CALL, + [CALL_TYPE_1] = CALL, + [CALL_STR_1] = CALL, + [CALL_TUPLE_1] = CALL, + [CALL_ALLOC_AND_ENTER_INIT] = CALL, + [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, + [CALL_BUILTIN_CLASS] = CALL, + [CALL_BUILTIN_O] = CALL, + [CALL_BUILTIN_FAST] = CALL, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, + [CALL_LEN] = CALL, + [CALL_ISINSTANCE] = CALL, + [CALL_LIST_APPEND] = CALL, + [CALL_METHOD_DESCRIPTOR_O] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, + [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST] = CALL, + [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, + [CALL_KW] = CALL_KW, + [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, + [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, + [MAKE_FUNCTION] = MAKE_FUNCTION, + [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, + [RETURN_GENERATOR] = RETURN_GENERATOR, + [BUILD_SLICE] = BUILD_SLICE, + [CONVERT_VALUE] = CONVERT_VALUE, + [FORMAT_SIMPLE] = FORMAT_SIMPLE, + [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC, + [COPY] = COPY, + [SWAP] = SWAP, + [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, + [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, + [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, + [EXTENDED_ARG] = EXTENDED_ARG, + [CACHE] = CACHE, + [RESERVED] = RESERVED, + [END_FOR] = END_FOR, + [TO_BOOL] = TO_BOOL, + [BINARY_OP_MULTIPLY_INT] = BINARY_OP, + [BINARY_OP_ADD_INT] = BINARY_OP, + [BINARY_OP_SUBTRACT_INT] = BINARY_OP, + [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, + [BINARY_OP_ADD_FLOAT] = BINARY_OP, + [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, + [BINARY_OP_ADD_UNICODE] = BINARY_OP, + [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, + [BINARY_SUBSCR] = BINARY_SUBSCR, + [STORE_SUBSCR] = STORE_SUBSCR, + [RETURN_VALUE] = RETURN_VALUE, + [RETURN_CONST] = RETURN_CONST, + [SEND] = SEND, + [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, + [STORE_ATTR] = STORE_ATTR, + [LOAD_GLOBAL] = LOAD_GLOBAL, + [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, + [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, + [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, + [LOAD_ATTR] = LOAD_ATTR, + [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, + [LOAD_ATTR_MODULE] = LOAD_ATTR, + [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, + [LOAD_ATTR_SLOT] = LOAD_ATTR, + [LOAD_ATTR_CLASS] = LOAD_ATTR, + [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, + [STORE_ATTR_SLOT] = STORE_ATTR, + [COMPARE_OP] = COMPARE_OP, + [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, + [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, + [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, + [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, + [FOR_ITER] = FOR_ITER, + [FOR_ITER_LIST] = FOR_ITER, + [FOR_ITER_TUPLE] = FOR_ITER, + [FOR_ITER_RANGE] = FOR_ITER, + [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, + [CALL] = CALL, + [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, + [CALL_PY_EXACT_ARGS] = CALL, + [BINARY_OP] = BINARY_OP, }; -struct opcode_macro_expansion { - int nuops; - struct { int16_t uop; int8_t size; int8_t offset; } uops[12]; +const uint8_t _PyOpcode_Caches[256] = { + [TO_BOOL_BOOL] = 3, + [TO_BOOL_INT] = 3, + [TO_BOOL_LIST] = 3, + [TO_BOOL_NONE] = 3, + [TO_BOOL_STR] = 3, + [TO_BOOL_ALWAYS_TRUE] = 3, + [BINARY_SUBSCR_LIST_INT] = 1, + [BINARY_SUBSCR_STR_INT] = 1, + [BINARY_SUBSCR_TUPLE_INT] = 1, + [BINARY_SUBSCR_DICT] = 1, + [BINARY_SUBSCR_GETITEM] = 1, + [STORE_SUBSCR_LIST_INT] = 1, + [STORE_SUBSCR_DICT] = 1, + [SEND_GEN] = 1, + [UNPACK_SEQUENCE_TWO_TUPLE] = 1, + [UNPACK_SEQUENCE_TUPLE] = 1, + [UNPACK_SEQUENCE_LIST] = 1, + [INSTRUMENTED_LOAD_SUPER_ATTR] = 1, + [LOAD_SUPER_ATTR_ATTR] = 1, + [LOAD_SUPER_ATTR_METHOD] = 1, + [LOAD_ATTR_PROPERTY] = 9, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = 9, + [STORE_ATTR_WITH_HINT] = 4, + [COMPARE_OP_FLOAT] = 1, + [COMPARE_OP_INT] = 1, + [COMPARE_OP_STR] = 1, + [JUMP_BACKWARD] = 1, + [INSTRUMENTED_FOR_ITER] = 1, + [FOR_ITER_GEN] = 1, + [INSTRUMENTED_CALL] = 3, + [CALL_PY_WITH_DEFAULTS] = 3, + [CALL_TYPE_1] = 3, + [CALL_STR_1] = 3, + [CALL_TUPLE_1] = 3, + [CALL_ALLOC_AND_ENTER_INIT] = 3, + [CALL_BUILTIN_CLASS] = 3, + [CALL_BUILTIN_O] = 3, + [CALL_BUILTIN_FAST] = 3, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = 3, + [CALL_LEN] = 3, + [CALL_ISINSTANCE] = 3, + [CALL_LIST_APPEND] = 3, + [CALL_METHOD_DESCRIPTOR_O] = 3, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = 3, + [CALL_METHOD_DESCRIPTOR_NOARGS] = 3, + [CALL_METHOD_DESCRIPTOR_FAST] = 3, + [INSTRUMENTED_JUMP_BACKWARD] = 1, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = 1, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = 1, + [INSTRUMENTED_POP_JUMP_IF_NONE] = 1, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = 1, + [TO_BOOL] = 3, + [BINARY_OP_MULTIPLY_INT] = 1, + [BINARY_OP_ADD_INT] = 1, + [BINARY_OP_SUBTRACT_INT] = 1, + [BINARY_OP_MULTIPLY_FLOAT] = 1, + [BINARY_OP_ADD_FLOAT] = 1, + [BINARY_OP_SUBTRACT_FLOAT] = 1, + [BINARY_OP_ADD_UNICODE] = 1, + [BINARY_OP_INPLACE_ADD_UNICODE] = 1, + [BINARY_SUBSCR] = 1, + [STORE_SUBSCR] = 1, + [SEND] = 1, + [UNPACK_SEQUENCE] = 1, + [STORE_ATTR] = 4, + [LOAD_GLOBAL] = 4, + [LOAD_GLOBAL_MODULE] = 4, + [LOAD_GLOBAL_BUILTIN] = 4, + [LOAD_SUPER_ATTR] = 1, + [LOAD_ATTR] = 9, + [LOAD_ATTR_INSTANCE_VALUE] = 9, + [LOAD_ATTR_MODULE] = 9, + [LOAD_ATTR_WITH_HINT] = 9, + [LOAD_ATTR_SLOT] = 9, + [LOAD_ATTR_CLASS] = 9, + [STORE_ATTR_INSTANCE_VALUE] = 4, + [STORE_ATTR_SLOT] = 4, + [COMPARE_OP] = 1, + [POP_JUMP_IF_TRUE] = 1, + [POP_JUMP_IF_FALSE] = 1, + [POP_JUMP_IF_NONE] = 1, + [POP_JUMP_IF_NOT_NONE] = 1, + [FOR_ITER] = 1, + [FOR_ITER_LIST] = 1, + [FOR_ITER_TUPLE] = 1, + [FOR_ITER_RANGE] = 1, + [LOAD_ATTR_METHOD_WITH_VALUES] = 9, + [LOAD_ATTR_METHOD_NO_DICT] = 9, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = 9, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = 9, + [LOAD_ATTR_METHOD_LAZY_DICT] = 9, + [CALL] = 3, + [CALL_BOUND_METHOD_EXACT_ARGS] = 3, + [CALL_PY_EXACT_ARGS] = 3, + [BINARY_OP] = 1, }; -#define OPARG_FULL 0 -#define OPARG_CACHE_1 1 -#define OPARG_CACHE_2 2 -#define OPARG_CACHE_4 4 -#define OPARG_TOP 5 -#define OPARG_BOTTOM 6 -#define OPARG_SAVE_RETURN_OFFSET 7 - -#define OPCODE_METADATA_FLAGS(OP) (_PyOpcode_opcode_metadata[(OP)].flags & (HAS_ARG_FLAG | HAS_JUMP_FLAG)) -#define SAME_OPCODE_METADATA(OP1, OP2) \ - (OPCODE_METADATA_FLAGS(OP1) == OPCODE_METADATA_FLAGS(OP2)) - -#define OPCODE_METADATA_SIZE 512 -#define OPCODE_UOP_NAME_SIZE 512 -#define OPCODE_MACRO_EXPANSION_SIZE 256 +struct opcode_metadata { + uint8_t valid_entry; + uint8_t instr_format; + uint16_t flags; +}; -extern const struct opcode_metadata _PyOpcode_opcode_metadata[OPCODE_METADATA_SIZE]; -#ifdef NEED_OPCODE_METADATA -const struct opcode_metadata _PyOpcode_opcode_metadata[OPCODE_METADATA_SIZE] = { +const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [NOP] = { true, INSTR_FMT_IX, 0 }, - [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [RESUME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_CLOSURE] = { true, 0, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, - [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG }, - [LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, - [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, - [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, - [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, - [STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, - [STORE_FAST_MAYBE_NULL] = { true, 0, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, - [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, - [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, + [LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, + [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, 0 }, + [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, + [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_CONST_FLAG }, + [STORE_FAST] = { true, INSTR_FMT_IB, 0 }, + [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, + [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, 0 }, [POP_TOP] = { true, INSTR_FMT_IX, 0 }, [PUSH_NULL] = { true, INSTR_FMT_IX, 0 }, - [END_FOR] = { true, INSTR_FMT_IX, 0 }, - [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [END_SEND] = { true, INSTR_FMT_IX, 0 }, - [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [UNARY_NOT] = { true, INSTR_FMT_IX, 0 }, - [_SPECIALIZE_TO_BOOL] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG }, - [_TO_BOOL] = { true, INSTR_FMT_IXC0, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [TO_BOOL_BOOL] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_LIST] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_NONE] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, - [UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_GUARD_BOTH_INT] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG }, - [_BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG }, - [_BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG }, - [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, - [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, - [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, - [_GUARD_BOTH_FLOAT] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, 0 }, - [_BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, 0 }, - [_BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, 0 }, - [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [_GUARD_BOTH_UNICODE] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG }, - [_BINARY_SUBSCR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [BINARY_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [SET_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG }, - [_STORE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [STORE_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, + [SET_ADD] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [STORE_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [_POP_FRAME] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [GET_AITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [GET_ANEXT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [GET_AWAITABLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_SEND] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG }, - [_SEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_CONST_FLAG }, + [GET_AITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_ANEXT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_AWAITABLE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, [POP_EXCEPT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [RERAISE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CLEANUP_THROW] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [RERAISE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CLEANUP_THROW] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [LOAD_ASSERTION_ERROR] = { true, INSTR_FMT_IX, 0 }, - [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [_UNPACK_SEQUENCE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [UNPACK_SEQUENCE_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [UNPACK_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_STORE_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG }, - [_STORE_ATTR] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_LOCALS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_LOAD_GLOBAL] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG }, - [_LOAD_GLOBAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_GUARD_GLOBALS_VERSION] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [_GUARD_BUILTINS_VERSION] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [_LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_LOAD_GLOBAL_BUILTINS] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG }, - [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG }, - [COPY_FREE_VARS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_CONST_KEY_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DICT_MERGE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, - [_SPECIALIZE_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_SUPER_METHOD] = { true, 0, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_ZERO_SUPER_METHOD] = { true, 0, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_ZERO_SUPER_ATTR] = { true, 0, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_LOAD_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG }, - [_LOAD_ATTR] = { true, INSTR_FMT_IBC0000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_METHOD] = { true, 0, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_GUARD_TYPE_VERSION] = { true, INSTR_FMT_IXC0, HAS_DEOPT_FLAG }, - [_CHECK_MANAGED_OBJECT_HAS_VALUES] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_CHECK_ATTR_MODULE] = { true, INSTR_FMT_IXC0, HAS_DEOPT_FLAG }, - [_LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_CHECK_ATTR_WITH_HINT] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [_LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [_LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_CHECK_ATTR_CLASS] = { true, INSTR_FMT_IXC0, HAS_DEOPT_FLAG }, - [_LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG }, - [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [_GUARD_DORV_VALUES] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG }, - [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [_STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG }, - [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [_COMPARE_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [COMPARE_OP_FLOAT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [COMPARE_OP_INT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [COMPARE_OP_STR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [IS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [CONTAINS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [JUMP] = { true, 0, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [JUMP_NO_INTERRUPT] = { true, 0, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [_IS_NONE] = { true, INSTR_FMT_IX, 0 }, - [POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [GET_LEN] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, + [UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, + [UNPACK_SEQUENCE_LIST] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, + [UNPACK_EX] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_LOCALS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, + [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, + [COPY_FREE_VARS] = { true, INSTR_FMT_IB, 0 }, + [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_CONST_KEY_MAP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DICT_MERGE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, 0 }, + [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [COMPARE_OP_FLOAT] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [COMPARE_OP_INT] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [COMPARE_OP_STR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [IS_OP] = { true, INSTR_FMT_IB, 0 }, + [CONTAINS_OP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_JUMP_FLAG }, + [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, + [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_JUMP_FLAG }, + [GET_LEN] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [MATCH_MAPPING] = { true, INSTR_FMT_IX, 0 }, [MATCH_SEQUENCE] = { true, INSTR_FMT_IX, 0 }, - [MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [GET_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [_FOR_ITER] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_FOR_ITER_TIER_TWO] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_ITER_CHECK_LIST] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_ITER_JUMP_LIST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [_GUARD_NOT_EXHAUSTED_LIST] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_ITER_NEXT_LIST] = { true, INSTR_FMT_IX, 0 }, - [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_DEOPT_FLAG }, - [_ITER_CHECK_TUPLE] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_ITER_JUMP_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [_GUARD_NOT_EXHAUSTED_TUPLE] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_ITER_NEXT_TUPLE] = { true, INSTR_FMT_IX, 0 }, - [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_DEOPT_FLAG }, - [_ITER_CHECK_RANGE] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_ITER_JUMP_RANGE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, - [_GUARD_NOT_EXHAUSTED_RANGE] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_ITER_NEXT_RANGE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [FOR_ITER_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [BEFORE_ASYNC_WITH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BEFORE_WITH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [SETUP_FINALLY] = { true, 0, HAS_ARG_FLAG }, - [SETUP_CLEANUP] = { true, 0, HAS_ARG_FLAG }, - [SETUP_WITH] = { true, 0, HAS_ARG_FLAG }, - [POP_BLOCK] = { true, 0, 0 }, + [MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [FOR_ITER_GEN] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [BEFORE_ASYNC_WITH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BEFORE_WITH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [PUSH_EXC_INFO] = { true, INSTR_FMT_IX, 0 }, - [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_GUARD_KEYS_VERSION] = { true, INSTR_FMT_IXC0, HAS_DEOPT_FLAG }, - [_LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [_LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG }, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG }, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_CHECK_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_SPECIALIZE_CALL] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [_CALL] = { true, INSTR_FMT_IBC0, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [_CHECK_PEP_523] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_CHECK_FUNCTION_EXACT_ARGS] = { true, INSTR_FMT_IBC0, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_CHECK_STACK_SPACE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [_INIT_CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [_PUSH_FRAME] = { true, INSTR_FMT_IX, 0 }, - [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [CALL_PY_WITH_DEFAULTS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, - [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, - [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_KW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_PY_WITH_DEFAULTS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_DEOPT_FLAG }, + [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_KW] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, - [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [FORMAT_SIMPLE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [FORMAT_WITH_SPEC] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [COPY] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [_SPECIALIZE_BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [_BINARY_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [SWAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG }, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, - [INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, - [EXTENDED_ARG] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, + [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, + [FORMAT_SIMPLE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [FORMAT_WITH_SPEC] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [COPY] = { true, INSTR_FMT_IB, 0 }, + [SWAP] = { true, INSTR_FMT_IB, 0 }, + [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, 0 }, + [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, 0 }, + [EXTENDED_ARG] = { true, INSTR_FMT_IB, 0 }, [CACHE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, [RESERVED] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [_GUARD_IS_TRUE_POP] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_GUARD_IS_FALSE_POP] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_GUARD_IS_NONE_POP] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_GUARD_IS_NOT_NONE_POP] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [_JUMP_TO_TOP] = { true, INSTR_FMT_IX, HAS_EVAL_BREAK_FLAG }, - [_SET_IP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [_SAVE_RETURN_OFFSET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [_EXIT_TRACE] = { true, INSTR_FMT_IX, 0 }, - [_INSERT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [_CHECK_VALIDITY] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, -}; -#endif // NEED_OPCODE_METADATA - -extern const struct opcode_macro_expansion _PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE]; -#ifdef NEED_OPCODE_METADATA -const struct opcode_macro_expansion _PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE] = { - [NOP] = { .nuops = 1, .uops = { { NOP, 0, 0 } } }, - [RESUME_CHECK] = { .nuops = 1, .uops = { { RESUME_CHECK, 0, 0 } } }, - [LOAD_FAST_CHECK] = { .nuops = 1, .uops = { { LOAD_FAST_CHECK, 0, 0 } } }, - [LOAD_FAST] = { .nuops = 1, .uops = { { LOAD_FAST, 0, 0 } } }, - [LOAD_FAST_AND_CLEAR] = { .nuops = 1, .uops = { { LOAD_FAST_AND_CLEAR, 0, 0 } } }, - [LOAD_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { LOAD_FAST, 5, 0 }, { LOAD_FAST, 6, 0 } } }, - [LOAD_CONST] = { .nuops = 1, .uops = { { LOAD_CONST, 0, 0 } } }, - [STORE_FAST] = { .nuops = 1, .uops = { { STORE_FAST, 0, 0 } } }, - [STORE_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { STORE_FAST, 5, 0 }, { LOAD_FAST, 6, 0 } } }, - [STORE_FAST_STORE_FAST] = { .nuops = 2, .uops = { { STORE_FAST, 5, 0 }, { STORE_FAST, 6, 0 } } }, - [POP_TOP] = { .nuops = 1, .uops = { { POP_TOP, 0, 0 } } }, - [PUSH_NULL] = { .nuops = 1, .uops = { { PUSH_NULL, 0, 0 } } }, - [END_FOR] = { .nuops = 2, .uops = { { POP_TOP, 0, 0 }, { POP_TOP, 0, 0 } } }, - [END_SEND] = { .nuops = 1, .uops = { { END_SEND, 0, 0 } } }, - [UNARY_NEGATIVE] = { .nuops = 1, .uops = { { UNARY_NEGATIVE, 0, 0 } } }, - [UNARY_NOT] = { .nuops = 1, .uops = { { UNARY_NOT, 0, 0 } } }, - [TO_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL, 0, 0 } } }, - [TO_BOOL_BOOL] = { .nuops = 1, .uops = { { TO_BOOL_BOOL, 0, 0 } } }, - [TO_BOOL_INT] = { .nuops = 1, .uops = { { TO_BOOL_INT, 0, 0 } } }, - [TO_BOOL_LIST] = { .nuops = 1, .uops = { { TO_BOOL_LIST, 0, 0 } } }, - [TO_BOOL_NONE] = { .nuops = 1, .uops = { { TO_BOOL_NONE, 0, 0 } } }, - [TO_BOOL_STR] = { .nuops = 1, .uops = { { TO_BOOL_STR, 0, 0 } } }, - [TO_BOOL_ALWAYS_TRUE] = { .nuops = 1, .uops = { { TO_BOOL_ALWAYS_TRUE, 2, 1 } } }, - [UNARY_INVERT] = { .nuops = 1, .uops = { { UNARY_INVERT, 0, 0 } } }, - [BINARY_OP_MULTIPLY_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_MULTIPLY_INT, 0, 0 } } }, - [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_ADD_INT, 0, 0 } } }, - [BINARY_OP_SUBTRACT_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_SUBTRACT_INT, 0, 0 } } }, - [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT, 0, 0 } } }, - [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_ADD_FLOAT, 0, 0 } } }, - [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, 0, 0 } } }, - [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_ADD_UNICODE, 0, 0 } } }, - [BINARY_SUBSCR] = { .nuops = 1, .uops = { { _BINARY_SUBSCR, 0, 0 } } }, - [BINARY_SLICE] = { .nuops = 1, .uops = { { BINARY_SLICE, 0, 0 } } }, - [STORE_SLICE] = { .nuops = 1, .uops = { { STORE_SLICE, 0, 0 } } }, - [BINARY_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { BINARY_SUBSCR_LIST_INT, 0, 0 } } }, - [BINARY_SUBSCR_STR_INT] = { .nuops = 1, .uops = { { BINARY_SUBSCR_STR_INT, 0, 0 } } }, - [BINARY_SUBSCR_TUPLE_INT] = { .nuops = 1, .uops = { { BINARY_SUBSCR_TUPLE_INT, 0, 0 } } }, - [BINARY_SUBSCR_DICT] = { .nuops = 1, .uops = { { BINARY_SUBSCR_DICT, 0, 0 } } }, - [LIST_APPEND] = { .nuops = 1, .uops = { { LIST_APPEND, 0, 0 } } }, - [SET_ADD] = { .nuops = 1, .uops = { { SET_ADD, 0, 0 } } }, - [STORE_SUBSCR] = { .nuops = 1, .uops = { { _STORE_SUBSCR, 0, 0 } } }, - [STORE_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { STORE_SUBSCR_LIST_INT, 0, 0 } } }, - [STORE_SUBSCR_DICT] = { .nuops = 1, .uops = { { STORE_SUBSCR_DICT, 0, 0 } } }, - [DELETE_SUBSCR] = { .nuops = 1, .uops = { { DELETE_SUBSCR, 0, 0 } } }, - [CALL_INTRINSIC_1] = { .nuops = 1, .uops = { { CALL_INTRINSIC_1, 0, 0 } } }, - [CALL_INTRINSIC_2] = { .nuops = 1, .uops = { { CALL_INTRINSIC_2, 0, 0 } } }, - [RETURN_VALUE] = { .nuops = 1, .uops = { { _POP_FRAME, 0, 0 } } }, - [RETURN_CONST] = { .nuops = 2, .uops = { { LOAD_CONST, 0, 0 }, { _POP_FRAME, 0, 0 } } }, - [GET_AITER] = { .nuops = 1, .uops = { { GET_AITER, 0, 0 } } }, - [GET_ANEXT] = { .nuops = 1, .uops = { { GET_ANEXT, 0, 0 } } }, - [GET_AWAITABLE] = { .nuops = 1, .uops = { { GET_AWAITABLE, 0, 0 } } }, - [POP_EXCEPT] = { .nuops = 1, .uops = { { POP_EXCEPT, 0, 0 } } }, - [LOAD_ASSERTION_ERROR] = { .nuops = 1, .uops = { { LOAD_ASSERTION_ERROR, 0, 0 } } }, - [LOAD_BUILD_CLASS] = { .nuops = 1, .uops = { { LOAD_BUILD_CLASS, 0, 0 } } }, - [STORE_NAME] = { .nuops = 1, .uops = { { STORE_NAME, 0, 0 } } }, - [DELETE_NAME] = { .nuops = 1, .uops = { { DELETE_NAME, 0, 0 } } }, - [UNPACK_SEQUENCE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE, 0, 0 } } }, - [UNPACK_SEQUENCE_TWO_TUPLE] = { .nuops = 1, .uops = { { UNPACK_SEQUENCE_TWO_TUPLE, 0, 0 } } }, - [UNPACK_SEQUENCE_TUPLE] = { .nuops = 1, .uops = { { UNPACK_SEQUENCE_TUPLE, 0, 0 } } }, - [UNPACK_SEQUENCE_LIST] = { .nuops = 1, .uops = { { UNPACK_SEQUENCE_LIST, 0, 0 } } }, - [UNPACK_EX] = { .nuops = 1, .uops = { { UNPACK_EX, 0, 0 } } }, - [STORE_ATTR] = { .nuops = 1, .uops = { { _STORE_ATTR, 0, 0 } } }, - [DELETE_ATTR] = { .nuops = 1, .uops = { { DELETE_ATTR, 0, 0 } } }, - [STORE_GLOBAL] = { .nuops = 1, .uops = { { STORE_GLOBAL, 0, 0 } } }, - [DELETE_GLOBAL] = { .nuops = 1, .uops = { { DELETE_GLOBAL, 0, 0 } } }, - [LOAD_LOCALS] = { .nuops = 1, .uops = { { LOAD_LOCALS, 0, 0 } } }, - [LOAD_FROM_DICT_OR_GLOBALS] = { .nuops = 1, .uops = { { LOAD_FROM_DICT_OR_GLOBALS, 0, 0 } } }, - [LOAD_NAME] = { .nuops = 1, .uops = { { LOAD_NAME, 0, 0 } } }, - [LOAD_GLOBAL] = { .nuops = 1, .uops = { { _LOAD_GLOBAL, 0, 0 } } }, - [LOAD_GLOBAL_MODULE] = { .nuops = 2, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _LOAD_GLOBAL_MODULE, 1, 3 } } }, - [LOAD_GLOBAL_BUILTIN] = { .nuops = 3, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _GUARD_BUILTINS_VERSION, 1, 2 }, { _LOAD_GLOBAL_BUILTINS, 1, 3 } } }, - [DELETE_FAST] = { .nuops = 1, .uops = { { DELETE_FAST, 0, 0 } } }, - [MAKE_CELL] = { .nuops = 1, .uops = { { MAKE_CELL, 0, 0 } } }, - [DELETE_DEREF] = { .nuops = 1, .uops = { { DELETE_DEREF, 0, 0 } } }, - [LOAD_FROM_DICT_OR_DEREF] = { .nuops = 1, .uops = { { LOAD_FROM_DICT_OR_DEREF, 0, 0 } } }, - [LOAD_DEREF] = { .nuops = 1, .uops = { { LOAD_DEREF, 0, 0 } } }, - [STORE_DEREF] = { .nuops = 1, .uops = { { STORE_DEREF, 0, 0 } } }, - [COPY_FREE_VARS] = { .nuops = 1, .uops = { { COPY_FREE_VARS, 0, 0 } } }, - [BUILD_STRING] = { .nuops = 1, .uops = { { BUILD_STRING, 0, 0 } } }, - [BUILD_TUPLE] = { .nuops = 1, .uops = { { BUILD_TUPLE, 0, 0 } } }, - [BUILD_LIST] = { .nuops = 1, .uops = { { BUILD_LIST, 0, 0 } } }, - [LIST_EXTEND] = { .nuops = 1, .uops = { { LIST_EXTEND, 0, 0 } } }, - [SET_UPDATE] = { .nuops = 1, .uops = { { SET_UPDATE, 0, 0 } } }, - [BUILD_SET] = { .nuops = 1, .uops = { { BUILD_SET, 0, 0 } } }, - [BUILD_MAP] = { .nuops = 1, .uops = { { BUILD_MAP, 0, 0 } } }, - [SETUP_ANNOTATIONS] = { .nuops = 1, .uops = { { SETUP_ANNOTATIONS, 0, 0 } } }, - [BUILD_CONST_KEY_MAP] = { .nuops = 1, .uops = { { BUILD_CONST_KEY_MAP, 0, 0 } } }, - [DICT_UPDATE] = { .nuops = 1, .uops = { { DICT_UPDATE, 0, 0 } } }, - [DICT_MERGE] = { .nuops = 1, .uops = { { DICT_MERGE, 0, 0 } } }, - [MAP_ADD] = { .nuops = 1, .uops = { { MAP_ADD, 0, 0 } } }, - [LOAD_SUPER_ATTR_ATTR] = { .nuops = 1, .uops = { { LOAD_SUPER_ATTR_ATTR, 0, 0 } } }, - [LOAD_SUPER_ATTR_METHOD] = { .nuops = 1, .uops = { { LOAD_SUPER_ATTR_METHOD, 0, 0 } } }, - [LOAD_ATTR] = { .nuops = 1, .uops = { { _LOAD_ATTR, 0, 0 } } }, - [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES, 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE, 1, 3 } } }, - [LOAD_ATTR_MODULE] = { .nuops = 2, .uops = { { _CHECK_ATTR_MODULE, 2, 1 }, { _LOAD_ATTR_MODULE, 1, 3 } } }, - [LOAD_ATTR_WITH_HINT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_WITH_HINT, 0, 0 }, { _LOAD_ATTR_WITH_HINT, 1, 3 } } }, - [LOAD_ATTR_SLOT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_SLOT, 1, 3 } } }, - [LOAD_ATTR_CLASS] = { .nuops = 2, .uops = { { _CHECK_ATTR_CLASS, 2, 1 }, { _LOAD_ATTR_CLASS, 4, 5 } } }, - [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES, 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE, 1, 3 } } }, - [STORE_ATTR_SLOT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _STORE_ATTR_SLOT, 1, 3 } } }, - [COMPARE_OP] = { .nuops = 1, .uops = { { _COMPARE_OP, 0, 0 } } }, - [COMPARE_OP_FLOAT] = { .nuops = 1, .uops = { { COMPARE_OP_FLOAT, 0, 0 } } }, - [COMPARE_OP_INT] = { .nuops = 1, .uops = { { COMPARE_OP_INT, 0, 0 } } }, - [COMPARE_OP_STR] = { .nuops = 1, .uops = { { COMPARE_OP_STR, 0, 0 } } }, - [IS_OP] = { .nuops = 1, .uops = { { IS_OP, 0, 0 } } }, - [CONTAINS_OP] = { .nuops = 1, .uops = { { CONTAINS_OP, 0, 0 } } }, - [CHECK_EG_MATCH] = { .nuops = 1, .uops = { { CHECK_EG_MATCH, 0, 0 } } }, - [CHECK_EXC_MATCH] = { .nuops = 1, .uops = { { CHECK_EXC_MATCH, 0, 0 } } }, - [POP_JUMP_IF_TRUE] = { .nuops = 1, .uops = { { _POP_JUMP_IF_TRUE, 0, 0 } } }, - [POP_JUMP_IF_FALSE] = { .nuops = 1, .uops = { { _POP_JUMP_IF_FALSE, 0, 0 } } }, - [POP_JUMP_IF_NONE] = { .nuops = 2, .uops = { { _IS_NONE, 0, 0 }, { _POP_JUMP_IF_TRUE, 0, 0 } } }, - [POP_JUMP_IF_NOT_NONE] = { .nuops = 2, .uops = { { _IS_NONE, 0, 0 }, { _POP_JUMP_IF_FALSE, 0, 0 } } }, - [GET_LEN] = { .nuops = 1, .uops = { { GET_LEN, 0, 0 } } }, - [MATCH_CLASS] = { .nuops = 1, .uops = { { MATCH_CLASS, 0, 0 } } }, - [MATCH_MAPPING] = { .nuops = 1, .uops = { { MATCH_MAPPING, 0, 0 } } }, - [MATCH_SEQUENCE] = { .nuops = 1, .uops = { { MATCH_SEQUENCE, 0, 0 } } }, - [MATCH_KEYS] = { .nuops = 1, .uops = { { MATCH_KEYS, 0, 0 } } }, - [GET_ITER] = { .nuops = 1, .uops = { { GET_ITER, 0, 0 } } }, - [GET_YIELD_FROM_ITER] = { .nuops = 1, .uops = { { GET_YIELD_FROM_ITER, 0, 0 } } }, - [FOR_ITER] = { .nuops = 1, .uops = { { _FOR_ITER, 0, 0 } } }, - [FOR_ITER_LIST] = { .nuops = 3, .uops = { { _ITER_CHECK_LIST, 0, 0 }, { _ITER_JUMP_LIST, 0, 0 }, { _ITER_NEXT_LIST, 0, 0 } } }, - [FOR_ITER_TUPLE] = { .nuops = 3, .uops = { { _ITER_CHECK_TUPLE, 0, 0 }, { _ITER_JUMP_TUPLE, 0, 0 }, { _ITER_NEXT_TUPLE, 0, 0 } } }, - [FOR_ITER_RANGE] = { .nuops = 3, .uops = { { _ITER_CHECK_RANGE, 0, 0 }, { _ITER_JUMP_RANGE, 0, 0 }, { _ITER_NEXT_RANGE, 0, 0 } } }, - [BEFORE_ASYNC_WITH] = { .nuops = 1, .uops = { { BEFORE_ASYNC_WITH, 0, 0 } } }, - [BEFORE_WITH] = { .nuops = 1, .uops = { { BEFORE_WITH, 0, 0 } } }, - [WITH_EXCEPT_START] = { .nuops = 1, .uops = { { WITH_EXCEPT_START, 0, 0 } } }, - [PUSH_EXC_INFO] = { .nuops = 1, .uops = { { PUSH_EXC_INFO, 0, 0 } } }, - [LOAD_ATTR_METHOD_WITH_VALUES] = { .nuops = 4, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, 0, 0 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES, 4, 5 } } }, - [LOAD_ATTR_METHOD_NO_DICT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_METHOD_NO_DICT, 4, 5 } } }, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nuops = 4, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, 0, 0 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES, 4, 5 } } }, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT, 4, 5 } } }, - [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT, 0, 0 }, { _LOAD_ATTR_METHOD_LAZY_DICT, 4, 5 } } }, - [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 8, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, - [CALL_PY_EXACT_ARGS] = { .nuops = 6, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, - [CALL_TYPE_1] = { .nuops = 1, .uops = { { CALL_TYPE_1, 0, 0 } } }, - [CALL_STR_1] = { .nuops = 1, .uops = { { CALL_STR_1, 0, 0 } } }, - [CALL_TUPLE_1] = { .nuops = 1, .uops = { { CALL_TUPLE_1, 0, 0 } } }, - [EXIT_INIT_CHECK] = { .nuops = 1, .uops = { { EXIT_INIT_CHECK, 0, 0 } } }, - [CALL_BUILTIN_CLASS] = { .nuops = 1, .uops = { { CALL_BUILTIN_CLASS, 0, 0 } } }, - [CALL_BUILTIN_O] = { .nuops = 1, .uops = { { CALL_BUILTIN_O, 0, 0 } } }, - [CALL_BUILTIN_FAST] = { .nuops = 1, .uops = { { CALL_BUILTIN_FAST, 0, 0 } } }, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { CALL_BUILTIN_FAST_WITH_KEYWORDS, 0, 0 } } }, - [CALL_LEN] = { .nuops = 1, .uops = { { CALL_LEN, 0, 0 } } }, - [CALL_ISINSTANCE] = { .nuops = 1, .uops = { { CALL_ISINSTANCE, 0, 0 } } }, - [CALL_METHOD_DESCRIPTOR_O] = { .nuops = 1, .uops = { { CALL_METHOD_DESCRIPTOR_O, 0, 0 } } }, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, 0, 0 } } }, - [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nuops = 1, .uops = { { CALL_METHOD_DESCRIPTOR_NOARGS, 0, 0 } } }, - [CALL_METHOD_DESCRIPTOR_FAST] = { .nuops = 1, .uops = { { CALL_METHOD_DESCRIPTOR_FAST, 0, 0 } } }, - [MAKE_FUNCTION] = { .nuops = 1, .uops = { { MAKE_FUNCTION, 0, 0 } } }, - [SET_FUNCTION_ATTRIBUTE] = { .nuops = 1, .uops = { { SET_FUNCTION_ATTRIBUTE, 0, 0 } } }, - [BUILD_SLICE] = { .nuops = 1, .uops = { { BUILD_SLICE, 0, 0 } } }, - [CONVERT_VALUE] = { .nuops = 1, .uops = { { CONVERT_VALUE, 0, 0 } } }, - [FORMAT_SIMPLE] = { .nuops = 1, .uops = { { FORMAT_SIMPLE, 0, 0 } } }, - [FORMAT_WITH_SPEC] = { .nuops = 1, .uops = { { FORMAT_WITH_SPEC, 0, 0 } } }, - [COPY] = { .nuops = 1, .uops = { { COPY, 0, 0 } } }, - [BINARY_OP] = { .nuops = 1, .uops = { { _BINARY_OP, 0, 0 } } }, - [SWAP] = { .nuops = 1, .uops = { { SWAP, 0, 0 } } }, + [END_FOR] = { true, INSTR_FMT_IX, 0 }, + [TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, + [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, + [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, + [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_CONST_FLAG }, + [SEND] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, + [UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC000, HAS_DEOPT_FLAG }, + [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_DEOPT_FLAG }, + [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, + [POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, + [POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, + [POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, + [FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, + [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [CALL] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, }; -#endif // NEED_OPCODE_METADATA -extern const char * const _PyOpcode_uop_name[OPCODE_UOP_NAME_SIZE]; -#ifdef NEED_OPCODE_METADATA -const char * const _PyOpcode_uop_name[OPCODE_UOP_NAME_SIZE] = { - [_EXIT_TRACE] = "_EXIT_TRACE", - [_SET_IP] = "_SET_IP", - [_SPECIALIZE_TO_BOOL] = "_SPECIALIZE_TO_BOOL", - [_TO_BOOL] = "_TO_BOOL", - [_GUARD_BOTH_INT] = "_GUARD_BOTH_INT", - [_BINARY_OP_MULTIPLY_INT] = "_BINARY_OP_MULTIPLY_INT", - [_BINARY_OP_ADD_INT] = "_BINARY_OP_ADD_INT", - [_BINARY_OP_SUBTRACT_INT] = "_BINARY_OP_SUBTRACT_INT", - [_GUARD_BOTH_FLOAT] = "_GUARD_BOTH_FLOAT", - [_BINARY_OP_MULTIPLY_FLOAT] = "_BINARY_OP_MULTIPLY_FLOAT", - [_BINARY_OP_ADD_FLOAT] = "_BINARY_OP_ADD_FLOAT", - [_BINARY_OP_SUBTRACT_FLOAT] = "_BINARY_OP_SUBTRACT_FLOAT", - [_GUARD_BOTH_UNICODE] = "_GUARD_BOTH_UNICODE", - [_BINARY_OP_ADD_UNICODE] = "_BINARY_OP_ADD_UNICODE", - [_BINARY_OP_INPLACE_ADD_UNICODE] = "_BINARY_OP_INPLACE_ADD_UNICODE", - [_SPECIALIZE_BINARY_SUBSCR] = "_SPECIALIZE_BINARY_SUBSCR", - [_BINARY_SUBSCR] = "_BINARY_SUBSCR", - [_SPECIALIZE_STORE_SUBSCR] = "_SPECIALIZE_STORE_SUBSCR", - [_STORE_SUBSCR] = "_STORE_SUBSCR", - [_POP_FRAME] = "_POP_FRAME", - [_SPECIALIZE_SEND] = "_SPECIALIZE_SEND", - [_SEND] = "_SEND", - [_SPECIALIZE_UNPACK_SEQUENCE] = "_SPECIALIZE_UNPACK_SEQUENCE", - [_UNPACK_SEQUENCE] = "_UNPACK_SEQUENCE", - [_SPECIALIZE_STORE_ATTR] = "_SPECIALIZE_STORE_ATTR", - [_STORE_ATTR] = "_STORE_ATTR", - [_SPECIALIZE_LOAD_GLOBAL] = "_SPECIALIZE_LOAD_GLOBAL", - [_LOAD_GLOBAL] = "_LOAD_GLOBAL", - [_GUARD_GLOBALS_VERSION] = "_GUARD_GLOBALS_VERSION", - [_GUARD_BUILTINS_VERSION] = "_GUARD_BUILTINS_VERSION", - [_LOAD_GLOBAL_MODULE] = "_LOAD_GLOBAL_MODULE", - [_LOAD_GLOBAL_BUILTINS] = "_LOAD_GLOBAL_BUILTINS", - [_SPECIALIZE_LOAD_SUPER_ATTR] = "_SPECIALIZE_LOAD_SUPER_ATTR", - [_LOAD_SUPER_ATTR] = "_LOAD_SUPER_ATTR", - [_SPECIALIZE_LOAD_ATTR] = "_SPECIALIZE_LOAD_ATTR", - [_LOAD_ATTR] = "_LOAD_ATTR", - [_GUARD_TYPE_VERSION] = "_GUARD_TYPE_VERSION", - [_CHECK_MANAGED_OBJECT_HAS_VALUES] = "_CHECK_MANAGED_OBJECT_HAS_VALUES", - [_LOAD_ATTR_INSTANCE_VALUE] = "_LOAD_ATTR_INSTANCE_VALUE", - [_CHECK_ATTR_MODULE] = "_CHECK_ATTR_MODULE", - [_LOAD_ATTR_MODULE] = "_LOAD_ATTR_MODULE", - [_CHECK_ATTR_WITH_HINT] = "_CHECK_ATTR_WITH_HINT", - [_LOAD_ATTR_WITH_HINT] = "_LOAD_ATTR_WITH_HINT", - [_LOAD_ATTR_SLOT] = "_LOAD_ATTR_SLOT", - [_CHECK_ATTR_CLASS] = "_CHECK_ATTR_CLASS", - [_LOAD_ATTR_CLASS] = "_LOAD_ATTR_CLASS", - [_GUARD_DORV_VALUES] = "_GUARD_DORV_VALUES", - [_STORE_ATTR_INSTANCE_VALUE] = "_STORE_ATTR_INSTANCE_VALUE", - [_STORE_ATTR_SLOT] = "_STORE_ATTR_SLOT", - [_SPECIALIZE_COMPARE_OP] = "_SPECIALIZE_COMPARE_OP", - [_COMPARE_OP] = "_COMPARE_OP", - [_POP_JUMP_IF_FALSE] = "_POP_JUMP_IF_FALSE", - [_POP_JUMP_IF_TRUE] = "_POP_JUMP_IF_TRUE", - [_IS_NONE] = "_IS_NONE", - [_SPECIALIZE_FOR_ITER] = "_SPECIALIZE_FOR_ITER", - [_FOR_ITER] = "_FOR_ITER", - [_FOR_ITER_TIER_TWO] = "_FOR_ITER_TIER_TWO", - [_ITER_CHECK_LIST] = "_ITER_CHECK_LIST", - [_ITER_JUMP_LIST] = "_ITER_JUMP_LIST", - [_GUARD_NOT_EXHAUSTED_LIST] = "_GUARD_NOT_EXHAUSTED_LIST", - [_ITER_NEXT_LIST] = "_ITER_NEXT_LIST", - [_ITER_CHECK_TUPLE] = "_ITER_CHECK_TUPLE", - [_ITER_JUMP_TUPLE] = "_ITER_JUMP_TUPLE", - [_GUARD_NOT_EXHAUSTED_TUPLE] = "_GUARD_NOT_EXHAUSTED_TUPLE", - [_ITER_NEXT_TUPLE] = "_ITER_NEXT_TUPLE", - [_ITER_CHECK_RANGE] = "_ITER_CHECK_RANGE", - [_ITER_JUMP_RANGE] = "_ITER_JUMP_RANGE", - [_GUARD_NOT_EXHAUSTED_RANGE] = "_GUARD_NOT_EXHAUSTED_RANGE", - [_ITER_NEXT_RANGE] = "_ITER_NEXT_RANGE", - [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT", - [_GUARD_KEYS_VERSION] = "_GUARD_KEYS_VERSION", - [_LOAD_ATTR_METHOD_WITH_VALUES] = "_LOAD_ATTR_METHOD_WITH_VALUES", - [_LOAD_ATTR_METHOD_NO_DICT] = "_LOAD_ATTR_METHOD_NO_DICT", - [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = "_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES", - [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "_LOAD_ATTR_NONDESCRIPTOR_NO_DICT", - [_CHECK_ATTR_METHOD_LAZY_DICT] = "_CHECK_ATTR_METHOD_LAZY_DICT", - [_LOAD_ATTR_METHOD_LAZY_DICT] = "_LOAD_ATTR_METHOD_LAZY_DICT", - [_SPECIALIZE_CALL] = "_SPECIALIZE_CALL", - [_CALL] = "_CALL", - [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = "_CHECK_CALL_BOUND_METHOD_EXACT_ARGS", - [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = "_INIT_CALL_BOUND_METHOD_EXACT_ARGS", - [_CHECK_PEP_523] = "_CHECK_PEP_523", - [_CHECK_FUNCTION_EXACT_ARGS] = "_CHECK_FUNCTION_EXACT_ARGS", - [_CHECK_STACK_SPACE] = "_CHECK_STACK_SPACE", - [_INIT_CALL_PY_EXACT_ARGS] = "_INIT_CALL_PY_EXACT_ARGS", - [_PUSH_FRAME] = "_PUSH_FRAME", - [_SPECIALIZE_BINARY_OP] = "_SPECIALIZE_BINARY_OP", - [_BINARY_OP] = "_BINARY_OP", - [_GUARD_IS_TRUE_POP] = "_GUARD_IS_TRUE_POP", - [_GUARD_IS_FALSE_POP] = "_GUARD_IS_FALSE_POP", - [_GUARD_IS_NONE_POP] = "_GUARD_IS_NONE_POP", - [_GUARD_IS_NOT_NONE_POP] = "_GUARD_IS_NOT_NONE_POP", - [_JUMP_TO_TOP] = "_JUMP_TO_TOP", - [_SAVE_RETURN_OFFSET] = "_SAVE_RETURN_OFFSET", - [_INSERT] = "_INSERT", - [_CHECK_VALIDITY] = "_CHECK_VALIDITY", -}; -#endif // NEED_OPCODE_METADATA +#define IS_VALID_OPCODE(OP) \ + (((OP) >= 0) && ((OP) < 256) && \ + (_PyOpcode_opcode_metadata[(OP)].valid_entry)) -extern const char *const _PyOpcode_OpName[268]; -#ifdef NEED_OPCODE_METADATA -const char *const _PyOpcode_OpName[268] = { - [CACHE] = "CACHE", - [RESERVED] = "RESERVED", - [RESUME] = "RESUME", +const char *_PyOpcode_OpName[268] = { [BEFORE_ASYNC_WITH] = "BEFORE_ASYNC_WITH", [BEFORE_WITH] = "BEFORE_WITH", + [BINARY_OP] = "BINARY_OP", + [BINARY_OP_ADD_FLOAT] = "BINARY_OP_ADD_FLOAT", + [BINARY_OP_ADD_INT] = "BINARY_OP_ADD_INT", + [BINARY_OP_ADD_UNICODE] = "BINARY_OP_ADD_UNICODE", [BINARY_OP_INPLACE_ADD_UNICODE] = "BINARY_OP_INPLACE_ADD_UNICODE", + [BINARY_OP_MULTIPLY_FLOAT] = "BINARY_OP_MULTIPLY_FLOAT", + [BINARY_OP_MULTIPLY_INT] = "BINARY_OP_MULTIPLY_INT", + [BINARY_OP_SUBTRACT_FLOAT] = "BINARY_OP_SUBTRACT_FLOAT", + [BINARY_OP_SUBTRACT_INT] = "BINARY_OP_SUBTRACT_INT", [BINARY_SLICE] = "BINARY_SLICE", [BINARY_SUBSCR] = "BINARY_SUBSCR", - [CHECK_EG_MATCH] = "CHECK_EG_MATCH", - [CHECK_EXC_MATCH] = "CHECK_EXC_MATCH", - [CLEANUP_THROW] = "CLEANUP_THROW", - [DELETE_SUBSCR] = "DELETE_SUBSCR", - [END_ASYNC_FOR] = "END_ASYNC_FOR", - [END_FOR] = "END_FOR", - [END_SEND] = "END_SEND", - [EXIT_INIT_CHECK] = "EXIT_INIT_CHECK", - [FORMAT_SIMPLE] = "FORMAT_SIMPLE", - [FORMAT_WITH_SPEC] = "FORMAT_WITH_SPEC", - [GET_AITER] = "GET_AITER", - [GET_ANEXT] = "GET_ANEXT", - [GET_ITER] = "GET_ITER", - [GET_LEN] = "GET_LEN", - [GET_YIELD_FROM_ITER] = "GET_YIELD_FROM_ITER", - [INTERPRETER_EXIT] = "INTERPRETER_EXIT", - [LOAD_ASSERTION_ERROR] = "LOAD_ASSERTION_ERROR", - [LOAD_BUILD_CLASS] = "LOAD_BUILD_CLASS", - [LOAD_LOCALS] = "LOAD_LOCALS", - [MAKE_FUNCTION] = "MAKE_FUNCTION", - [MATCH_KEYS] = "MATCH_KEYS", - [MATCH_MAPPING] = "MATCH_MAPPING", - [MATCH_SEQUENCE] = "MATCH_SEQUENCE", - [NOP] = "NOP", - [POP_EXCEPT] = "POP_EXCEPT", - [POP_TOP] = "POP_TOP", - [PUSH_EXC_INFO] = "PUSH_EXC_INFO", - [PUSH_NULL] = "PUSH_NULL", - [RETURN_GENERATOR] = "RETURN_GENERATOR", - [RETURN_VALUE] = "RETURN_VALUE", - [SETUP_ANNOTATIONS] = "SETUP_ANNOTATIONS", - [STORE_SLICE] = "STORE_SLICE", - [STORE_SUBSCR] = "STORE_SUBSCR", - [TO_BOOL] = "TO_BOOL", - [UNARY_INVERT] = "UNARY_INVERT", - [UNARY_NEGATIVE] = "UNARY_NEGATIVE", - [UNARY_NOT] = "UNARY_NOT", - [WITH_EXCEPT_START] = "WITH_EXCEPT_START", - [BINARY_OP] = "BINARY_OP", + [BINARY_SUBSCR_DICT] = "BINARY_SUBSCR_DICT", + [BINARY_SUBSCR_GETITEM] = "BINARY_SUBSCR_GETITEM", + [BINARY_SUBSCR_LIST_INT] = "BINARY_SUBSCR_LIST_INT", + [BINARY_SUBSCR_STR_INT] = "BINARY_SUBSCR_STR_INT", + [BINARY_SUBSCR_TUPLE_INT] = "BINARY_SUBSCR_TUPLE_INT", [BUILD_CONST_KEY_MAP] = "BUILD_CONST_KEY_MAP", [BUILD_LIST] = "BUILD_LIST", [BUILD_MAP] = "BUILD_MAP", @@ -2017,12 +613,37 @@ const char *const _PyOpcode_OpName[268] = { [BUILD_SLICE] = "BUILD_SLICE", [BUILD_STRING] = "BUILD_STRING", [BUILD_TUPLE] = "BUILD_TUPLE", + [CACHE] = "CACHE", [CALL] = "CALL", + [CALL_ALLOC_AND_ENTER_INIT] = "CALL_ALLOC_AND_ENTER_INIT", + [CALL_BOUND_METHOD_EXACT_ARGS] = "CALL_BOUND_METHOD_EXACT_ARGS", + [CALL_BUILTIN_CLASS] = "CALL_BUILTIN_CLASS", + [CALL_BUILTIN_FAST] = "CALL_BUILTIN_FAST", + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = "CALL_BUILTIN_FAST_WITH_KEYWORDS", + [CALL_BUILTIN_O] = "CALL_BUILTIN_O", [CALL_FUNCTION_EX] = "CALL_FUNCTION_EX", [CALL_INTRINSIC_1] = "CALL_INTRINSIC_1", [CALL_INTRINSIC_2] = "CALL_INTRINSIC_2", + [CALL_ISINSTANCE] = "CALL_ISINSTANCE", [CALL_KW] = "CALL_KW", + [CALL_LEN] = "CALL_LEN", + [CALL_LIST_APPEND] = "CALL_LIST_APPEND", + [CALL_METHOD_DESCRIPTOR_FAST] = "CALL_METHOD_DESCRIPTOR_FAST", + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = "CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", + [CALL_METHOD_DESCRIPTOR_NOARGS] = "CALL_METHOD_DESCRIPTOR_NOARGS", + [CALL_METHOD_DESCRIPTOR_O] = "CALL_METHOD_DESCRIPTOR_O", + [CALL_PY_EXACT_ARGS] = "CALL_PY_EXACT_ARGS", + [CALL_PY_WITH_DEFAULTS] = "CALL_PY_WITH_DEFAULTS", + [CALL_STR_1] = "CALL_STR_1", + [CALL_TUPLE_1] = "CALL_TUPLE_1", + [CALL_TYPE_1] = "CALL_TYPE_1", + [CHECK_EG_MATCH] = "CHECK_EG_MATCH", + [CHECK_EXC_MATCH] = "CHECK_EXC_MATCH", + [CLEANUP_THROW] = "CLEANUP_THROW", [COMPARE_OP] = "COMPARE_OP", + [COMPARE_OP_FLOAT] = "COMPARE_OP_FLOAT", + [COMPARE_OP_INT] = "COMPARE_OP_INT", + [COMPARE_OP_STR] = "COMPARE_OP_STR", [CONTAINS_OP] = "CONTAINS_OP", [CONVERT_VALUE] = "CONVERT_VALUE", [COPY] = "COPY", @@ -2032,21 +653,73 @@ const char *const _PyOpcode_OpName[268] = { [DELETE_FAST] = "DELETE_FAST", [DELETE_GLOBAL] = "DELETE_GLOBAL", [DELETE_NAME] = "DELETE_NAME", + [DELETE_SUBSCR] = "DELETE_SUBSCR", [DICT_MERGE] = "DICT_MERGE", [DICT_UPDATE] = "DICT_UPDATE", + [END_ASYNC_FOR] = "END_ASYNC_FOR", + [END_FOR] = "END_FOR", + [END_SEND] = "END_SEND", [ENTER_EXECUTOR] = "ENTER_EXECUTOR", + [EXIT_INIT_CHECK] = "EXIT_INIT_CHECK", [EXTENDED_ARG] = "EXTENDED_ARG", + [FORMAT_SIMPLE] = "FORMAT_SIMPLE", + [FORMAT_WITH_SPEC] = "FORMAT_WITH_SPEC", [FOR_ITER] = "FOR_ITER", + [FOR_ITER_GEN] = "FOR_ITER_GEN", + [FOR_ITER_LIST] = "FOR_ITER_LIST", + [FOR_ITER_RANGE] = "FOR_ITER_RANGE", + [FOR_ITER_TUPLE] = "FOR_ITER_TUPLE", + [GET_AITER] = "GET_AITER", + [GET_ANEXT] = "GET_ANEXT", [GET_AWAITABLE] = "GET_AWAITABLE", + [GET_ITER] = "GET_ITER", + [GET_LEN] = "GET_LEN", + [GET_YIELD_FROM_ITER] = "GET_YIELD_FROM_ITER", [IMPORT_FROM] = "IMPORT_FROM", [IMPORT_NAME] = "IMPORT_NAME", + [INSTRUMENTED_CALL] = "INSTRUMENTED_CALL", + [INSTRUMENTED_CALL_FUNCTION_EX] = "INSTRUMENTED_CALL_FUNCTION_EX", + [INSTRUMENTED_CALL_KW] = "INSTRUMENTED_CALL_KW", + [INSTRUMENTED_END_FOR] = "INSTRUMENTED_END_FOR", + [INSTRUMENTED_END_SEND] = "INSTRUMENTED_END_SEND", + [INSTRUMENTED_FOR_ITER] = "INSTRUMENTED_FOR_ITER", + [INSTRUMENTED_INSTRUCTION] = "INSTRUMENTED_INSTRUCTION", + [INSTRUMENTED_JUMP_BACKWARD] = "INSTRUMENTED_JUMP_BACKWARD", + [INSTRUMENTED_JUMP_FORWARD] = "INSTRUMENTED_JUMP_FORWARD", + [INSTRUMENTED_LOAD_SUPER_ATTR] = "INSTRUMENTED_LOAD_SUPER_ATTR", + [INSTRUMENTED_POP_JUMP_IF_FALSE] = "INSTRUMENTED_POP_JUMP_IF_FALSE", + [INSTRUMENTED_POP_JUMP_IF_NONE] = "INSTRUMENTED_POP_JUMP_IF_NONE", + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = "INSTRUMENTED_POP_JUMP_IF_NOT_NONE", + [INSTRUMENTED_POP_JUMP_IF_TRUE] = "INSTRUMENTED_POP_JUMP_IF_TRUE", + [INSTRUMENTED_RESUME] = "INSTRUMENTED_RESUME", + [INSTRUMENTED_RETURN_CONST] = "INSTRUMENTED_RETURN_CONST", + [INSTRUMENTED_RETURN_VALUE] = "INSTRUMENTED_RETURN_VALUE", + [INSTRUMENTED_YIELD_VALUE] = "INSTRUMENTED_YIELD_VALUE", + [INTERPRETER_EXIT] = "INTERPRETER_EXIT", [IS_OP] = "IS_OP", + [JUMP] = "JUMP", [JUMP_BACKWARD] = "JUMP_BACKWARD", [JUMP_BACKWARD_NO_INTERRUPT] = "JUMP_BACKWARD_NO_INTERRUPT", [JUMP_FORWARD] = "JUMP_FORWARD", + [JUMP_NO_INTERRUPT] = "JUMP_NO_INTERRUPT", [LIST_APPEND] = "LIST_APPEND", [LIST_EXTEND] = "LIST_EXTEND", + [LOAD_ASSERTION_ERROR] = "LOAD_ASSERTION_ERROR", [LOAD_ATTR] = "LOAD_ATTR", + [LOAD_ATTR_CLASS] = "LOAD_ATTR_CLASS", + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN", + [LOAD_ATTR_INSTANCE_VALUE] = "LOAD_ATTR_INSTANCE_VALUE", + [LOAD_ATTR_METHOD_LAZY_DICT] = "LOAD_ATTR_METHOD_LAZY_DICT", + [LOAD_ATTR_METHOD_NO_DICT] = "LOAD_ATTR_METHOD_NO_DICT", + [LOAD_ATTR_METHOD_WITH_VALUES] = "LOAD_ATTR_METHOD_WITH_VALUES", + [LOAD_ATTR_MODULE] = "LOAD_ATTR_MODULE", + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "LOAD_ATTR_NONDESCRIPTOR_NO_DICT", + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = "LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES", + [LOAD_ATTR_PROPERTY] = "LOAD_ATTR_PROPERTY", + [LOAD_ATTR_SLOT] = "LOAD_ATTR_SLOT", + [LOAD_ATTR_WITH_HINT] = "LOAD_ATTR_WITH_HINT", + [LOAD_BUILD_CLASS] = "LOAD_BUILD_CLASS", + [LOAD_CLOSURE] = "LOAD_CLOSURE", [LOAD_CONST] = "LOAD_CONST", [LOAD_DEREF] = "LOAD_DEREF", [LOAD_FAST] = "LOAD_FAST", @@ -2056,423 +729,120 @@ const char *const _PyOpcode_OpName[268] = { [LOAD_FROM_DICT_OR_DEREF] = "LOAD_FROM_DICT_OR_DEREF", [LOAD_FROM_DICT_OR_GLOBALS] = "LOAD_FROM_DICT_OR_GLOBALS", [LOAD_GLOBAL] = "LOAD_GLOBAL", + [LOAD_GLOBAL_BUILTIN] = "LOAD_GLOBAL_BUILTIN", + [LOAD_GLOBAL_MODULE] = "LOAD_GLOBAL_MODULE", + [LOAD_LOCALS] = "LOAD_LOCALS", + [LOAD_METHOD] = "LOAD_METHOD", [LOAD_NAME] = "LOAD_NAME", [LOAD_SUPER_ATTR] = "LOAD_SUPER_ATTR", + [LOAD_SUPER_ATTR_ATTR] = "LOAD_SUPER_ATTR_ATTR", + [LOAD_SUPER_ATTR_METHOD] = "LOAD_SUPER_ATTR_METHOD", + [LOAD_SUPER_METHOD] = "LOAD_SUPER_METHOD", + [LOAD_ZERO_SUPER_ATTR] = "LOAD_ZERO_SUPER_ATTR", + [LOAD_ZERO_SUPER_METHOD] = "LOAD_ZERO_SUPER_METHOD", [MAKE_CELL] = "MAKE_CELL", + [MAKE_FUNCTION] = "MAKE_FUNCTION", [MAP_ADD] = "MAP_ADD", [MATCH_CLASS] = "MATCH_CLASS", + [MATCH_KEYS] = "MATCH_KEYS", + [MATCH_MAPPING] = "MATCH_MAPPING", + [MATCH_SEQUENCE] = "MATCH_SEQUENCE", + [NOP] = "NOP", + [POP_BLOCK] = "POP_BLOCK", + [POP_EXCEPT] = "POP_EXCEPT", [POP_JUMP_IF_FALSE] = "POP_JUMP_IF_FALSE", [POP_JUMP_IF_NONE] = "POP_JUMP_IF_NONE", [POP_JUMP_IF_NOT_NONE] = "POP_JUMP_IF_NOT_NONE", [POP_JUMP_IF_TRUE] = "POP_JUMP_IF_TRUE", + [POP_TOP] = "POP_TOP", + [PUSH_EXC_INFO] = "PUSH_EXC_INFO", + [PUSH_NULL] = "PUSH_NULL", [RAISE_VARARGS] = "RAISE_VARARGS", [RERAISE] = "RERAISE", + [RESERVED] = "RESERVED", + [RESUME] = "RESUME", + [RESUME_CHECK] = "RESUME_CHECK", [RETURN_CONST] = "RETURN_CONST", + [RETURN_GENERATOR] = "RETURN_GENERATOR", + [RETURN_VALUE] = "RETURN_VALUE", [SEND] = "SEND", + [SEND_GEN] = "SEND_GEN", + [SETUP_ANNOTATIONS] = "SETUP_ANNOTATIONS", + [SETUP_CLEANUP] = "SETUP_CLEANUP", + [SETUP_FINALLY] = "SETUP_FINALLY", + [SETUP_WITH] = "SETUP_WITH", [SET_ADD] = "SET_ADD", [SET_FUNCTION_ATTRIBUTE] = "SET_FUNCTION_ATTRIBUTE", [SET_UPDATE] = "SET_UPDATE", [STORE_ATTR] = "STORE_ATTR", + [STORE_ATTR_INSTANCE_VALUE] = "STORE_ATTR_INSTANCE_VALUE", + [STORE_ATTR_SLOT] = "STORE_ATTR_SLOT", + [STORE_ATTR_WITH_HINT] = "STORE_ATTR_WITH_HINT", [STORE_DEREF] = "STORE_DEREF", [STORE_FAST] = "STORE_FAST", [STORE_FAST_LOAD_FAST] = "STORE_FAST_LOAD_FAST", + [STORE_FAST_MAYBE_NULL] = "STORE_FAST_MAYBE_NULL", [STORE_FAST_STORE_FAST] = "STORE_FAST_STORE_FAST", [STORE_GLOBAL] = "STORE_GLOBAL", [STORE_NAME] = "STORE_NAME", - [SWAP] = "SWAP", - [UNPACK_EX] = "UNPACK_EX", - [UNPACK_SEQUENCE] = "UNPACK_SEQUENCE", - [YIELD_VALUE] = "YIELD_VALUE", - [BINARY_OP_ADD_FLOAT] = "BINARY_OP_ADD_FLOAT", - [BINARY_OP_ADD_INT] = "BINARY_OP_ADD_INT", - [BINARY_OP_ADD_UNICODE] = "BINARY_OP_ADD_UNICODE", - [BINARY_OP_MULTIPLY_FLOAT] = "BINARY_OP_MULTIPLY_FLOAT", - [BINARY_OP_MULTIPLY_INT] = "BINARY_OP_MULTIPLY_INT", - [BINARY_OP_SUBTRACT_FLOAT] = "BINARY_OP_SUBTRACT_FLOAT", - [BINARY_OP_SUBTRACT_INT] = "BINARY_OP_SUBTRACT_INT", - [BINARY_SUBSCR_DICT] = "BINARY_SUBSCR_DICT", - [BINARY_SUBSCR_GETITEM] = "BINARY_SUBSCR_GETITEM", - [BINARY_SUBSCR_LIST_INT] = "BINARY_SUBSCR_LIST_INT", - [BINARY_SUBSCR_STR_INT] = "BINARY_SUBSCR_STR_INT", - [BINARY_SUBSCR_TUPLE_INT] = "BINARY_SUBSCR_TUPLE_INT", - [CALL_ALLOC_AND_ENTER_INIT] = "CALL_ALLOC_AND_ENTER_INIT", - [CALL_BOUND_METHOD_EXACT_ARGS] = "CALL_BOUND_METHOD_EXACT_ARGS", - [CALL_BUILTIN_CLASS] = "CALL_BUILTIN_CLASS", - [CALL_BUILTIN_FAST] = "CALL_BUILTIN_FAST", - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = "CALL_BUILTIN_FAST_WITH_KEYWORDS", - [CALL_BUILTIN_O] = "CALL_BUILTIN_O", - [CALL_ISINSTANCE] = "CALL_ISINSTANCE", - [CALL_LEN] = "CALL_LEN", - [CALL_LIST_APPEND] = "CALL_LIST_APPEND", - [CALL_METHOD_DESCRIPTOR_FAST] = "CALL_METHOD_DESCRIPTOR_FAST", - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = "CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", - [CALL_METHOD_DESCRIPTOR_NOARGS] = "CALL_METHOD_DESCRIPTOR_NOARGS", - [CALL_METHOD_DESCRIPTOR_O] = "CALL_METHOD_DESCRIPTOR_O", - [CALL_PY_EXACT_ARGS] = "CALL_PY_EXACT_ARGS", - [CALL_PY_WITH_DEFAULTS] = "CALL_PY_WITH_DEFAULTS", - [CALL_STR_1] = "CALL_STR_1", - [CALL_TUPLE_1] = "CALL_TUPLE_1", - [CALL_TYPE_1] = "CALL_TYPE_1", - [COMPARE_OP_FLOAT] = "COMPARE_OP_FLOAT", - [COMPARE_OP_INT] = "COMPARE_OP_INT", - [COMPARE_OP_STR] = "COMPARE_OP_STR", - [FOR_ITER_GEN] = "FOR_ITER_GEN", - [FOR_ITER_LIST] = "FOR_ITER_LIST", - [FOR_ITER_RANGE] = "FOR_ITER_RANGE", - [FOR_ITER_TUPLE] = "FOR_ITER_TUPLE", - [LOAD_ATTR_CLASS] = "LOAD_ATTR_CLASS", - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN", - [LOAD_ATTR_INSTANCE_VALUE] = "LOAD_ATTR_INSTANCE_VALUE", - [LOAD_ATTR_METHOD_LAZY_DICT] = "LOAD_ATTR_METHOD_LAZY_DICT", - [LOAD_ATTR_METHOD_NO_DICT] = "LOAD_ATTR_METHOD_NO_DICT", - [LOAD_ATTR_METHOD_WITH_VALUES] = "LOAD_ATTR_METHOD_WITH_VALUES", - [LOAD_ATTR_MODULE] = "LOAD_ATTR_MODULE", - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "LOAD_ATTR_NONDESCRIPTOR_NO_DICT", - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = "LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES", - [LOAD_ATTR_PROPERTY] = "LOAD_ATTR_PROPERTY", - [LOAD_ATTR_SLOT] = "LOAD_ATTR_SLOT", - [LOAD_ATTR_WITH_HINT] = "LOAD_ATTR_WITH_HINT", - [LOAD_GLOBAL_BUILTIN] = "LOAD_GLOBAL_BUILTIN", - [LOAD_GLOBAL_MODULE] = "LOAD_GLOBAL_MODULE", - [LOAD_SUPER_ATTR_ATTR] = "LOAD_SUPER_ATTR_ATTR", - [LOAD_SUPER_ATTR_METHOD] = "LOAD_SUPER_ATTR_METHOD", - [RESUME_CHECK] = "RESUME_CHECK", - [SEND_GEN] = "SEND_GEN", - [STORE_ATTR_INSTANCE_VALUE] = "STORE_ATTR_INSTANCE_VALUE", - [STORE_ATTR_SLOT] = "STORE_ATTR_SLOT", - [STORE_ATTR_WITH_HINT] = "STORE_ATTR_WITH_HINT", + [STORE_SLICE] = "STORE_SLICE", + [STORE_SUBSCR] = "STORE_SUBSCR", [STORE_SUBSCR_DICT] = "STORE_SUBSCR_DICT", [STORE_SUBSCR_LIST_INT] = "STORE_SUBSCR_LIST_INT", + [SWAP] = "SWAP", + [TO_BOOL] = "TO_BOOL", [TO_BOOL_ALWAYS_TRUE] = "TO_BOOL_ALWAYS_TRUE", [TO_BOOL_BOOL] = "TO_BOOL_BOOL", [TO_BOOL_INT] = "TO_BOOL_INT", [TO_BOOL_LIST] = "TO_BOOL_LIST", [TO_BOOL_NONE] = "TO_BOOL_NONE", [TO_BOOL_STR] = "TO_BOOL_STR", + [UNARY_INVERT] = "UNARY_INVERT", + [UNARY_NEGATIVE] = "UNARY_NEGATIVE", + [UNARY_NOT] = "UNARY_NOT", + [UNPACK_EX] = "UNPACK_EX", + [UNPACK_SEQUENCE] = "UNPACK_SEQUENCE", [UNPACK_SEQUENCE_LIST] = "UNPACK_SEQUENCE_LIST", [UNPACK_SEQUENCE_TUPLE] = "UNPACK_SEQUENCE_TUPLE", [UNPACK_SEQUENCE_TWO_TUPLE] = "UNPACK_SEQUENCE_TWO_TUPLE", - [INSTRUMENTED_RESUME] = "INSTRUMENTED_RESUME", - [INSTRUMENTED_END_FOR] = "INSTRUMENTED_END_FOR", - [INSTRUMENTED_END_SEND] = "INSTRUMENTED_END_SEND", - [INSTRUMENTED_RETURN_VALUE] = "INSTRUMENTED_RETURN_VALUE", - [INSTRUMENTED_RETURN_CONST] = "INSTRUMENTED_RETURN_CONST", - [INSTRUMENTED_YIELD_VALUE] = "INSTRUMENTED_YIELD_VALUE", - [INSTRUMENTED_LOAD_SUPER_ATTR] = "INSTRUMENTED_LOAD_SUPER_ATTR", - [INSTRUMENTED_FOR_ITER] = "INSTRUMENTED_FOR_ITER", - [INSTRUMENTED_CALL] = "INSTRUMENTED_CALL", - [INSTRUMENTED_CALL_KW] = "INSTRUMENTED_CALL_KW", - [INSTRUMENTED_CALL_FUNCTION_EX] = "INSTRUMENTED_CALL_FUNCTION_EX", - [INSTRUMENTED_INSTRUCTION] = "INSTRUMENTED_INSTRUCTION", - [INSTRUMENTED_JUMP_FORWARD] = "INSTRUMENTED_JUMP_FORWARD", - [INSTRUMENTED_JUMP_BACKWARD] = "INSTRUMENTED_JUMP_BACKWARD", - [INSTRUMENTED_POP_JUMP_IF_TRUE] = "INSTRUMENTED_POP_JUMP_IF_TRUE", - [INSTRUMENTED_POP_JUMP_IF_FALSE] = "INSTRUMENTED_POP_JUMP_IF_FALSE", - [INSTRUMENTED_POP_JUMP_IF_NONE] = "INSTRUMENTED_POP_JUMP_IF_NONE", - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = "INSTRUMENTED_POP_JUMP_IF_NOT_NONE", - [INSTRUMENTED_LINE] = "INSTRUMENTED_LINE", - [JUMP] = "JUMP", - [JUMP_NO_INTERRUPT] = "JUMP_NO_INTERRUPT", - [LOAD_CLOSURE] = "LOAD_CLOSURE", - [LOAD_METHOD] = "LOAD_METHOD", - [LOAD_SUPER_METHOD] = "LOAD_SUPER_METHOD", - [LOAD_ZERO_SUPER_ATTR] = "LOAD_ZERO_SUPER_ATTR", - [LOAD_ZERO_SUPER_METHOD] = "LOAD_ZERO_SUPER_METHOD", - [POP_BLOCK] = "POP_BLOCK", - [SETUP_CLEANUP] = "SETUP_CLEANUP", - [SETUP_FINALLY] = "SETUP_FINALLY", - [SETUP_WITH] = "SETUP_WITH", - [STORE_FAST_MAYBE_NULL] = "STORE_FAST_MAYBE_NULL", + [WITH_EXCEPT_START] = "WITH_EXCEPT_START", + [YIELD_VALUE] = "YIELD_VALUE", }; -#endif // NEED_OPCODE_METADATA -extern const uint8_t _PyOpcode_Caches[256]; -#ifdef NEED_OPCODE_METADATA -const uint8_t _PyOpcode_Caches[256] = { - [TO_BOOL] = 3, - [BINARY_OP_INPLACE_ADD_UNICODE] = 1, - [BINARY_SUBSCR] = 1, - [STORE_SUBSCR] = 1, - [SEND] = 1, - [UNPACK_SEQUENCE] = 1, - [STORE_ATTR] = 4, - [LOAD_GLOBAL] = 4, - [LOAD_SUPER_ATTR] = 1, - [LOAD_ATTR] = 9, - [COMPARE_OP] = 1, - [JUMP_BACKWARD] = 1, - [POP_JUMP_IF_TRUE] = 1, - [POP_JUMP_IF_FALSE] = 1, - [POP_JUMP_IF_NONE] = 1, - [POP_JUMP_IF_NOT_NONE] = 1, - [FOR_ITER] = 1, - [CALL] = 3, - [BINARY_OP] = 1, +struct pseudo_targets { + uint8_t targets[3]; }; -#endif // NEED_OPCODE_METADATA - -extern const uint8_t _PyOpcode_Deopt[256]; +const struct pseudo_targets pseudo_targets[12]; #ifdef NEED_OPCODE_METADATA -const uint8_t _PyOpcode_Deopt[256] = { - [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, - [BEFORE_WITH] = BEFORE_WITH, - [BINARY_OP] = BINARY_OP, - [BINARY_OP_ADD_FLOAT] = BINARY_OP, - [BINARY_OP_ADD_INT] = BINARY_OP, - [BINARY_OP_ADD_UNICODE] = BINARY_OP, - [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, - [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, - [BINARY_OP_MULTIPLY_INT] = BINARY_OP, - [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, - [BINARY_OP_SUBTRACT_INT] = BINARY_OP, - [BINARY_SLICE] = BINARY_SLICE, - [BINARY_SUBSCR] = BINARY_SUBSCR, - [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, - [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, - [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, - [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, - [BUILD_LIST] = BUILD_LIST, - [BUILD_MAP] = BUILD_MAP, - [BUILD_SET] = BUILD_SET, - [BUILD_SLICE] = BUILD_SLICE, - [BUILD_STRING] = BUILD_STRING, - [BUILD_TUPLE] = BUILD_TUPLE, - [CACHE] = CACHE, - [CALL] = CALL, - [CALL_ALLOC_AND_ENTER_INIT] = CALL, - [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, - [CALL_BUILTIN_CLASS] = CALL, - [CALL_BUILTIN_FAST] = CALL, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, - [CALL_BUILTIN_O] = CALL, - [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, - [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, - [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, - [CALL_ISINSTANCE] = CALL, - [CALL_KW] = CALL_KW, - [CALL_LEN] = CALL, - [CALL_LIST_APPEND] = CALL, - [CALL_METHOD_DESCRIPTOR_FAST] = CALL, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, - [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL, - [CALL_METHOD_DESCRIPTOR_O] = CALL, - [CALL_PY_EXACT_ARGS] = CALL, - [CALL_PY_WITH_DEFAULTS] = CALL, - [CALL_STR_1] = CALL, - [CALL_TUPLE_1] = CALL, - [CALL_TYPE_1] = CALL, - [CHECK_EG_MATCH] = CHECK_EG_MATCH, - [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, - [CLEANUP_THROW] = CLEANUP_THROW, - [COMPARE_OP] = COMPARE_OP, - [COMPARE_OP_FLOAT] = COMPARE_OP, - [COMPARE_OP_INT] = COMPARE_OP, - [COMPARE_OP_STR] = COMPARE_OP, - [CONTAINS_OP] = CONTAINS_OP, - [CONVERT_VALUE] = CONVERT_VALUE, - [COPY] = COPY, - [COPY_FREE_VARS] = COPY_FREE_VARS, - [DELETE_ATTR] = DELETE_ATTR, - [DELETE_DEREF] = DELETE_DEREF, - [DELETE_FAST] = DELETE_FAST, - [DELETE_GLOBAL] = DELETE_GLOBAL, - [DELETE_NAME] = DELETE_NAME, - [DELETE_SUBSCR] = DELETE_SUBSCR, - [DICT_MERGE] = DICT_MERGE, - [DICT_UPDATE] = DICT_UPDATE, - [END_ASYNC_FOR] = END_ASYNC_FOR, - [END_FOR] = END_FOR, - [END_SEND] = END_SEND, - [ENTER_EXECUTOR] = ENTER_EXECUTOR, - [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, - [EXTENDED_ARG] = EXTENDED_ARG, - [FORMAT_SIMPLE] = FORMAT_SIMPLE, - [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC, - [FOR_ITER] = FOR_ITER, - [FOR_ITER_GEN] = FOR_ITER, - [FOR_ITER_LIST] = FOR_ITER, - [FOR_ITER_RANGE] = FOR_ITER, - [FOR_ITER_TUPLE] = FOR_ITER, - [GET_AITER] = GET_AITER, - [GET_ANEXT] = GET_ANEXT, - [GET_AWAITABLE] = GET_AWAITABLE, - [GET_ITER] = GET_ITER, - [GET_LEN] = GET_LEN, - [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, - [IMPORT_FROM] = IMPORT_FROM, - [IMPORT_NAME] = IMPORT_NAME, - [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, - [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, - [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, - [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, - [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, - [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, - [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, - [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, - [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, - [INSTRUMENTED_LINE] = INSTRUMENTED_LINE, - [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, - [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, - [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, - [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST, - [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, - [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, - [INTERPRETER_EXIT] = INTERPRETER_EXIT, - [IS_OP] = IS_OP, - [JUMP_BACKWARD] = JUMP_BACKWARD, - [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, - [JUMP_FORWARD] = JUMP_FORWARD, - [LIST_APPEND] = LIST_APPEND, - [LIST_EXTEND] = LIST_EXTEND, - [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, - [LOAD_ATTR] = LOAD_ATTR, - [LOAD_ATTR_CLASS] = LOAD_ATTR, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, - [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, - [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, - [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, - [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, - [LOAD_ATTR_MODULE] = LOAD_ATTR, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, - [LOAD_ATTR_PROPERTY] = LOAD_ATTR, - [LOAD_ATTR_SLOT] = LOAD_ATTR, - [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, - [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, - [LOAD_CONST] = LOAD_CONST, - [LOAD_DEREF] = LOAD_DEREF, - [LOAD_FAST] = LOAD_FAST, - [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, - [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, - [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, - [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, - [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, - [LOAD_GLOBAL] = LOAD_GLOBAL, - [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, - [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, - [LOAD_LOCALS] = LOAD_LOCALS, - [LOAD_NAME] = LOAD_NAME, - [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, - [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, - [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, - [MAKE_CELL] = MAKE_CELL, - [MAKE_FUNCTION] = MAKE_FUNCTION, - [MAP_ADD] = MAP_ADD, - [MATCH_CLASS] = MATCH_CLASS, - [MATCH_KEYS] = MATCH_KEYS, - [MATCH_MAPPING] = MATCH_MAPPING, - [MATCH_SEQUENCE] = MATCH_SEQUENCE, - [NOP] = NOP, - [POP_EXCEPT] = POP_EXCEPT, - [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, - [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, - [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, - [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, - [POP_TOP] = POP_TOP, - [PUSH_EXC_INFO] = PUSH_EXC_INFO, - [PUSH_NULL] = PUSH_NULL, - [RAISE_VARARGS] = RAISE_VARARGS, - [RERAISE] = RERAISE, - [RESERVED] = RESERVED, - [RESUME] = RESUME, - [RESUME_CHECK] = RESUME, - [RETURN_CONST] = RETURN_CONST, - [RETURN_GENERATOR] = RETURN_GENERATOR, - [RETURN_VALUE] = RETURN_VALUE, - [SEND] = SEND, - [SEND_GEN] = SEND, - [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, - [SET_ADD] = SET_ADD, - [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, - [SET_UPDATE] = SET_UPDATE, - [STORE_ATTR] = STORE_ATTR, - [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, - [STORE_ATTR_SLOT] = STORE_ATTR, - [STORE_ATTR_WITH_HINT] = STORE_ATTR, - [STORE_DEREF] = STORE_DEREF, - [STORE_FAST] = STORE_FAST, - [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, - [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, - [STORE_GLOBAL] = STORE_GLOBAL, - [STORE_NAME] = STORE_NAME, - [STORE_SLICE] = STORE_SLICE, - [STORE_SUBSCR] = STORE_SUBSCR, - [STORE_SUBSCR_DICT] = STORE_SUBSCR, - [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, - [SWAP] = SWAP, - [TO_BOOL] = TO_BOOL, - [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, - [TO_BOOL_BOOL] = TO_BOOL, - [TO_BOOL_INT] = TO_BOOL, - [TO_BOOL_LIST] = TO_BOOL, - [TO_BOOL_NONE] = TO_BOOL, - [TO_BOOL_STR] = TO_BOOL, - [UNARY_INVERT] = UNARY_INVERT, - [UNARY_NEGATIVE] = UNARY_NEGATIVE, - [UNARY_NOT] = UNARY_NOT, - [UNPACK_EX] = UNPACK_EX, - [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, - [WITH_EXCEPT_START] = WITH_EXCEPT_START, - [YIELD_VALUE] = YIELD_VALUE, +const struct pseudo_targets pseudo_targets[12] = { + [LOAD_CLOSURE-256] = { { LOAD_FAST, 0, 0 } }, + [STORE_FAST_MAYBE_NULL-256] = { { STORE_FAST, 0, 0 } }, + [LOAD_SUPER_METHOD-256] = { { LOAD_SUPER_ATTR, 0, 0 } }, + [LOAD_ZERO_SUPER_METHOD-256] = { { LOAD_SUPER_ATTR, 0, 0 } }, + [LOAD_ZERO_SUPER_ATTR-256] = { { LOAD_SUPER_ATTR, 0, 0 } }, + [LOAD_METHOD-256] = { { LOAD_ATTR, 0, 0 } }, + [JUMP-256] = { { JUMP_FORWARD, JUMP_BACKWARD, 0 } }, + [JUMP_NO_INTERRUPT-256] = { { JUMP_FORWARD, JUMP_BACKWARD_NO_INTERRUPT, 0 } }, + [SETUP_FINALLY-256] = { { NOP, 0, 0 } }, + [SETUP_CLEANUP-256] = { { NOP, 0, 0 } }, + [SETUP_WITH-256] = { { NOP, 0, 0 } }, + [POP_BLOCK-256] = { { NOP, 0, 0 } }, }; + #endif // NEED_OPCODE_METADATA +static inline bool +is_pseudo_target(int pseudo, int target) { + if (pseudo < 256 || pseudo >= 268) { + return false; + } + for (int i = 0; pseudo_targets[pseudo-256].targets[i]; i++) { + if (pseudo_targets[pseudo-256].targets[i] == target) return true; + } + return false; +} -#define EXTRA_CASES \ - case 119: \ - case 120: \ - case 121: \ - case 122: \ - case 123: \ - case 124: \ - case 125: \ - case 126: \ - case 127: \ - case 128: \ - case 129: \ - case 130: \ - case 131: \ - case 132: \ - case 133: \ - case 134: \ - case 135: \ - case 136: \ - case 137: \ - case 138: \ - case 139: \ - case 140: \ - case 141: \ - case 142: \ - case 143: \ - case 144: \ - case 145: \ - case 146: \ - case 147: \ - case 148: \ - case 219: \ - case 220: \ - case 221: \ - case 222: \ - case 223: \ - case 224: \ - case 225: \ - case 226: \ - case 227: \ - case 228: \ - case 229: \ - case 230: \ - case 231: \ - case 232: \ - case 233: \ - case 234: \ - case 235: \ - case 255: \ - ; +#ifdef __cplusplus +} +#endif +#endif /* !Py_CORE_OPCODE_METADATA_H */ diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index c96ea51ae1acb6..c6b0d4b912a9d4 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -2,6 +2,7 @@ // from: // Python/bytecodes.c // Do not edit! + #ifndef Py_CORE_UOP_IDS_H #define Py_CORE_UOP_IDS_H #ifdef __cplusplus @@ -261,8 +262,9 @@ extern "C" { #define _SAVE_RETURN_OFFSET 393 #define _INSERT 394 #define _CHECK_VALIDITY 395 +#define MAX_UOP_ID 395 #ifdef __cplusplus } #endif -#endif /* !Py_OPCODE_IDS_H */ +#endif /* !Py_CORE_UOP_IDS_H */ diff --git a/Makefile.pre.in b/Makefile.pre.in index 5fb6ffc4e8f0cf..c349baa3739ebe 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -1588,7 +1588,6 @@ regen-cases: $(srcdir)/Tools/cases_generator/generate_cases.py \ $(CASESFLAG) \ -t $(srcdir)/Python/opcode_targets.h.new \ - -m $(srcdir)/Include/internal/pycore_opcode_metadata.h.new \ -p $(srcdir)/Lib/_opcode_metadata.py.new \ -a $(srcdir)/Python/abstract_interp_cases.c.h.new \ $(srcdir)/Python/bytecodes.c @@ -1600,11 +1599,16 @@ regen-cases: $(srcdir)/Tools/cases_generator/tier1_generator.py -o $(srcdir)/Python/generated_cases.c.h.new $(srcdir)/Python/bytecodes.c $(PYTHON_FOR_REGEN) \ $(srcdir)/Tools/cases_generator/tier2_generator.py -o $(srcdir)/Python/executor_cases.c.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) \ + $(srcdir)/Tools/cases_generator/opcode_metadata_generator.py -o $(srcdir)/Include/internal/pycore_opcode_metadata.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) \ + $(srcdir)/Tools/cases_generator/uop_metadata_generator.py -o $(srcdir)/Include/internal/pycore_uop_metadata.h.new $(srcdir)/Python/bytecodes.c $(UPDATE_FILE) $(srcdir)/Python/generated_cases.c.h $(srcdir)/Python/generated_cases.c.h.new $(UPDATE_FILE) $(srcdir)/Include/opcode_ids.h $(srcdir)/Include/opcode_ids.h.new $(UPDATE_FILE) $(srcdir)/Include/internal/pycore_uop_ids.h $(srcdir)/Include/internal/pycore_uop_ids.h.new $(UPDATE_FILE) $(srcdir)/Python/opcode_targets.h $(srcdir)/Python/opcode_targets.h.new $(UPDATE_FILE) $(srcdir)/Include/internal/pycore_opcode_metadata.h $(srcdir)/Include/internal/pycore_opcode_metadata.h.new + $(UPDATE_FILE) $(srcdir)/Include/internal/pycore_uop_metadata.h $(srcdir)/Include/internal/pycore_uop_metadata.h.new $(UPDATE_FILE) $(srcdir)/Python/executor_cases.c.h $(srcdir)/Python/executor_cases.c.h.new $(UPDATE_FILE) $(srcdir)/Python/abstract_interp_cases.c.h $(srcdir)/Python/abstract_interp_cases.c.h.new $(UPDATE_FILE) $(srcdir)/Lib/_opcode_metadata.py $(srcdir)/Lib/_opcode_metadata.py.new diff --git a/Python/assemble.c b/Python/assemble.c index b6fb432aed4a3b..98057e262f4b59 100644 --- a/Python/assemble.c +++ b/Python/assemble.c @@ -710,13 +710,13 @@ resolve_unconditional_jumps(instr_sequence *instrs) bool is_forward = (instr->i_oparg > i); switch(instr->i_opcode) { case JUMP: - assert(SAME_OPCODE_METADATA(JUMP, JUMP_FORWARD)); - assert(SAME_OPCODE_METADATA(JUMP, JUMP_BACKWARD)); + assert(is_pseudo_target(JUMP, JUMP_FORWARD)); + assert(is_pseudo_target(JUMP, JUMP_BACKWARD)); instr->i_opcode = is_forward ? JUMP_FORWARD : JUMP_BACKWARD; break; case JUMP_NO_INTERRUPT: - assert(SAME_OPCODE_METADATA(JUMP_NO_INTERRUPT, JUMP_FORWARD)); - assert(SAME_OPCODE_METADATA(JUMP_NO_INTERRUPT, JUMP_BACKWARD_NO_INTERRUPT)); + assert(is_pseudo_target(JUMP_NO_INTERRUPT, JUMP_FORWARD)); + assert(is_pseudo_target(JUMP_NO_INTERRUPT, JUMP_BACKWARD_NO_INTERRUPT)); instr->i_opcode = is_forward ? JUMP_FORWARD : JUMP_BACKWARD_NO_INTERRUPT; break; diff --git a/Python/ceval.c b/Python/ceval.c index d92ab926f84963..bd5b9c3977ace9 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -24,6 +24,7 @@ #include "pycore_sysmodule.h" // _PySys_Audit() #include "pycore_tuple.h" // _PyTuple_ITEMS() #include "pycore_typeobject.h" // _PySuper_Lookup() +#include "pycore_uop_ids.h" // Uops #include "pycore_uops.h" // _PyUOpExecutorObject #include "pycore_pyerrors.h" diff --git a/Python/compile.c b/Python/compile.c index 8b9e2f02048f11..dad2d37525e750 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -1125,7 +1125,7 @@ compiler_addop_name(struct compiler_unit *u, location loc, arg <<= 1; } if (opcode == LOAD_METHOD) { - assert(SAME_OPCODE_METADATA(LOAD_METHOD, LOAD_ATTR)); + assert(is_pseudo_target(LOAD_METHOD, LOAD_ATTR)); opcode = LOAD_ATTR; arg <<= 1; arg |= 1; @@ -1135,18 +1135,18 @@ compiler_addop_name(struct compiler_unit *u, location loc, arg |= 2; } if (opcode == LOAD_SUPER_METHOD) { - assert(SAME_OPCODE_METADATA(LOAD_SUPER_METHOD, LOAD_SUPER_ATTR)); + assert(is_pseudo_target(LOAD_SUPER_METHOD, LOAD_SUPER_ATTR)); opcode = LOAD_SUPER_ATTR; arg <<= 2; arg |= 3; } if (opcode == LOAD_ZERO_SUPER_ATTR) { - assert(SAME_OPCODE_METADATA(LOAD_ZERO_SUPER_ATTR, LOAD_SUPER_ATTR)); + assert(is_pseudo_target(LOAD_ZERO_SUPER_ATTR, LOAD_SUPER_ATTR)); opcode = LOAD_SUPER_ATTR; arg <<= 2; } if (opcode == LOAD_ZERO_SUPER_METHOD) { - assert(SAME_OPCODE_METADATA(LOAD_ZERO_SUPER_METHOD, LOAD_SUPER_ATTR)); + assert(is_pseudo_target(LOAD_ZERO_SUPER_METHOD, LOAD_SUPER_ATTR)); opcode = LOAD_SUPER_ATTR; arg <<= 2; arg |= 1; diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 9dda3c9a743258..f10384d4babdd3 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -3338,7 +3338,7 @@ PyObject *start; PyObject *slice; oparg = CURRENT_OPARG(); - if (oparg == 3) { step = stack_pointer[-(((oparg == 3) ? 1 : 0))]; } + if (oparg == 3) { step = stack_pointer[-(((oparg == 3) ? 1 : 0))]; } stop = stack_pointer[-1 - (((oparg == 3) ? 1 : 0))]; start = stack_pointer[-2 - (((oparg == 3) ? 1 : 0))]; slice = PySlice_New(start, stop, step); diff --git a/Python/flowgraph.c b/Python/flowgraph.c index fe632082d5a66c..de415c739942d4 100644 --- a/Python/flowgraph.c +++ b/Python/flowgraph.c @@ -2243,11 +2243,11 @@ convert_pseudo_ops(basicblock *entryblock) INSTR_SET_OP0(instr, NOP); } else if (instr->i_opcode == LOAD_CLOSURE) { - assert(SAME_OPCODE_METADATA(LOAD_CLOSURE, LOAD_FAST)); + assert(is_pseudo_target(LOAD_CLOSURE, LOAD_FAST)); instr->i_opcode = LOAD_FAST; } else if (instr->i_opcode == STORE_FAST_MAYBE_NULL) { - assert(SAME_OPCODE_METADATA(STORE_FAST_MAYBE_NULL, STORE_FAST)); + assert(is_pseudo_target(STORE_FAST_MAYBE_NULL, STORE_FAST)); instr->i_opcode = STORE_FAST; } } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 65e6f11f68b38c..a0b7b7db5cc76e 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -677,7 +677,7 @@ PyObject *stop; PyObject *start; PyObject *slice; - if (oparg == 3) { step = stack_pointer[-(((oparg == 3) ? 1 : 0))]; } + if (oparg == 3) { step = stack_pointer[-(((oparg == 3) ? 1 : 0))]; } stop = stack_pointer[-1 - (((oparg == 3) ? 1 : 0))]; start = stack_pointer[-2 - (((oparg == 3) ? 1 : 0))]; slice = PySlice_New(start, stop, step); @@ -1160,7 +1160,7 @@ PyObject *callargs; PyObject *func; PyObject *result; - if (oparg & 1) { kwargs = stack_pointer[-((oparg & 1))]; } + if (oparg & 1) { kwargs = stack_pointer[-((oparg & 1))]; } callargs = stack_pointer[-1 - ((oparg & 1))]; func = stack_pointer[-3 - ((oparg & 1))]; // DICT_MERGE is called before this opcode if there are kwargs. diff --git a/Python/optimizer.c b/Python/optimizer.c index d44e733bc346fa..9eb3d87696d45e 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -6,7 +6,9 @@ #include "pycore_opcode_utils.h" // MAX_REAL_OPCODE #include "pycore_optimizer.h" // _Py_uop_analyze_and_optimize() #include "pycore_pystate.h" // _PyInterpreterState_GET() +#include "pycore_uop_ids.h" #include "pycore_uops.h" +#include "pycore_uop_metadata.h" #include "cpython/optimizer.h" #include #include @@ -327,9 +329,6 @@ uop_dealloc(_PyUOpExecutorObject *self) { const char * _PyUOpName(int index) { - if (index <= MAX_REAL_OPCODE) { - return _PyOpcode_OpName[index]; - } return _PyOpcode_uop_name[index]; } @@ -388,7 +387,7 @@ PyTypeObject _PyUOpExecutor_Type = { /* TO DO -- Generate these tables */ static const uint16_t -_PyUOp_Replacements[OPCODE_METADATA_SIZE] = { +_PyUOp_Replacements[MAX_UOP_ID + 1] = { [_ITER_JUMP_RANGE] = _GUARD_NOT_EXHAUSTED_RANGE, [_ITER_JUMP_LIST] = _GUARD_NOT_EXHAUSTED_LIST, [_ITER_JUMP_TUPLE] = _GUARD_NOT_EXHAUSTED_TUPLE, diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index bcc13538e51d9b..e646f2c78604ae 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -16,6 +16,9 @@ class Properties: always_exits: bool stores_sp: bool tier_one_only: bool + uses_co_consts: bool + uses_co_names: bool + uses_locals: bool def dump(self, indent: str) -> None: print(indent, end="") @@ -35,6 +38,9 @@ def from_list(properties: list["Properties"]) -> "Properties": always_exits=any(p.always_exits for p in properties), stores_sp=any(p.stores_sp for p in properties), tier_one_only=any(p.tier_one_only for p in properties), + uses_co_consts=any(p.uses_co_consts for p in properties), + uses_co_names=any(p.uses_co_names for p in properties), + uses_locals=any(p.uses_locals for p in properties), ) @@ -49,6 +55,9 @@ def from_list(properties: list["Properties"]) -> "Properties": always_exits=False, stores_sp=False, tier_one_only=False, + uses_co_consts=False, + uses_co_names=False, + uses_locals=False, ) @@ -311,6 +320,9 @@ def compute_properties(op: parser.InstDef) -> Properties: always_exits=always_exits(op), stores_sp=variable_used(op, "STORE_SP"), tier_one_only=variable_used(op, "TIER_ONE_ONLY"), + uses_co_consts=variable_used(op, "FRAME_CO_CONSTS"), + uses_co_names=variable_used(op, "FRAME_CO_NAMES"), + uses_locals=variable_used(op, "GETLOCAL") or variable_used(op, "SETLOCAL"), ) diff --git a/Tools/cases_generator/cwriter.py b/Tools/cases_generator/cwriter.py index 34e39855a9b40a..b2e435811efa1d 100644 --- a/Tools/cases_generator/cwriter.py +++ b/Tools/cases_generator/cwriter.py @@ -1,5 +1,6 @@ +import contextlib from lexer import Token -from typing import TextIO +from typing import TextIO, Iterator class CWriter: @@ -35,26 +36,32 @@ def emit_at(self, txt: str, where: Token) -> None: self.out.write(txt) def maybe_dedent(self, txt: str) -> None: - parens = txt.count("(") - txt.count(")") + parens = txt.count("(") + txt.count("{") - txt.count(")") - txt.count("}") if parens < 0: self.indents.pop() - elif "}" in txt or is_label(txt): + elif is_label(txt): self.indents.pop() def maybe_indent(self, txt: str) -> None: parens = txt.count("(") - txt.count(")") - if parens > 0 and self.last_token: - offset = self.last_token.end_column - 1 - if offset <= self.indents[-1] or offset > 40: + if parens > 0: + if self.last_token: + offset = self.last_token.end_column - 1 + if offset <= self.indents[-1] or offset > 40: + offset = self.indents[-1] + 4 + else: offset = self.indents[-1] + 4 self.indents.append(offset) if is_label(txt): self.indents.append(self.indents[-1] + 4) - elif "{" in txt: - if 'extern "C"' in txt: - self.indents.append(self.indents[-1]) - else: - self.indents.append(self.indents[-1] + 4) + else: + braces = txt.count("{") - txt.count("}") + if braces > 0: + assert braces == 1 + if 'extern "C"' in txt: + self.indents.append(self.indents[-1]) + else: + self.indents.append(self.indents[-1] + 4) def emit_text(self, txt: str) -> None: self.out.write(txt) @@ -111,6 +118,26 @@ def start_line(self) -> None: self.newline = True self.last_token = None + @contextlib.contextmanager + def header_guard(self, name:str) -> Iterator[None]: + self.out.write(f""" +#ifndef {name} +#define {name} +#ifdef __cplusplus +extern "C" {{ +#endif + +""" + ) + yield + self.out.write(f""" +#ifdef __cplusplus +}} +#endif +#endif /* !{name} */ +""" + ) + def is_label(txt: str) -> bool: return not txt.startswith("//") and txt.endswith(":") diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index e0674a7343498d..e060ed813e24c4 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -10,6 +10,7 @@ Skip, StackItem, analysis_error, + Properties, ) from cwriter import CWriter from typing import Callable, Mapping, TextIO, Iterator @@ -184,3 +185,20 @@ def emit_tokens( replacement_functions[tkn.text](out, tkn, tkn_iter, uop, stack, inst) else: out.emit(tkn) + +def cflags(p: Properties) -> str: + flags: list[str] = [] + if p.escapes: + flags.append("HAS_ESCAPES_FLAG") + if not p.infallible: + flags.append("HAS_ERROR_FLAG") + if p.deopts: + flags.append("HAS_DEOPT_FLAG") + if p.jumps: + flags.append("HAS_JUMP_FLAG") + if p.uses_co_consts: + flags.append("HAS_CONST_FLAG") + if flags: + return " | ".join(flags) + else: + return "0" diff --git a/Tools/cases_generator/opcode_id_generator.py b/Tools/cases_generator/opcode_id_generator.py index ddbb409bbced39..b4e1b6fcf8112a 100644 --- a/Tools/cases_generator/opcode_id_generator.py +++ b/Tools/cases_generator/opcode_id_generator.py @@ -27,7 +27,6 @@ def generate_opcode_header(filenames: list[str], analysis: Analysis, outfile: TextIO) -> None: write_header(__file__, filenames, outfile) out = CWriter(outfile, 0, False) - out.emit("\n") instmap: dict[str, int] = {} # 0 is reserved for cache entries. This helps debugging. @@ -103,32 +102,19 @@ def add_instruction(name: str) -> None: assert 255 not in instmap.values() - out.emit( - """#ifndef Py_OPCODE_IDS_H -#define Py_OPCODE_IDS_H -#ifdef __cplusplus -extern "C" { -#endif + with out.header_guard("Py_OPCODE_IDS_H"): + out.emit("/* Instruction opcodes for compiled code */\n") -/* Instruction opcodes for compiled code */ -""" - ) - - def write_define(name: str, op: int) -> None: - out.emit(f"#define {name:<38} {op:>3}\n") + def write_define(name: str, op: int) -> None: + out.emit(f"#define {name:<38} {op:>3}\n") - for op, name in sorted([(op, name) for (name, op) in instmap.items()]): - write_define(name, op) + for op, name in sorted([(op, name) for (name, op) in instmap.items()]): + write_define(name, op) - out.emit("\n") - write_define("HAVE_ARGUMENT", len(no_arg)) - write_define("MIN_INSTRUMENTED_OPCODE", min_instrumented) + out.emit("\n") + write_define("HAVE_ARGUMENT", len(no_arg)) + write_define("MIN_INSTRUMENTED_OPCODE", min_instrumented) - out.emit("\n") - out.emit("#ifdef __cplusplus\n") - out.emit("}\n") - out.emit("#endif\n") - out.emit("#endif /* !Py_OPCODE_IDS_H */\n") arg_parser = argparse.ArgumentParser( diff --git a/Tools/cases_generator/uop_id_generator.py b/Tools/cases_generator/uop_id_generator.py index 277da25835f6fb..33cf5741226e6c 100644 --- a/Tools/cases_generator/uop_id_generator.py +++ b/Tools/cases_generator/uop_id_generator.py @@ -32,42 +32,29 @@ def generate_uop_ids( ) -> None: write_header(__file__, filenames, outfile) out = CWriter(outfile, 0, False) - out.emit( - """#ifndef Py_CORE_UOP_IDS_H -#define Py_CORE_UOP_IDS_H -#ifdef __cplusplus -extern "C" { -#endif - -""" - ) - - 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 - PRE_DEFINED = {"_EXIT_TRACE", "_SET_IP"} - - for uop in analysis.uops.values(): - if uop.name in PRE_DEFINED: - continue - # TODO: We should omit all tier-1 only uops, but - # generate_cases.py still generates code for those. - if uop.name in OMIT: - continue - if uop.implicitly_created and not distinct_namespace: - out.emit(f"#define {uop.name} {uop.name[1:]}\n") - else: - out.emit(f"#define {uop.name} {next_id}\n") - next_id += 1 - - out.emit("\n") - out.emit("#ifdef __cplusplus\n") - out.emit("}\n") - out.emit("#endif\n") - out.emit("#endif /* !Py_OPCODE_IDS_H */\n") + 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 + PRE_DEFINED = {"_EXIT_TRACE", "_SET_IP"} + + for uop in analysis.uops.values(): + if uop.name in PRE_DEFINED: + continue + # TODO: We should omit all tier-1 only uops, but + # generate_cases.py still generates code for those. + if uop.name in OMIT: + continue + if uop.implicitly_created and not distinct_namespace: + out.emit(f"#define {uop.name} {uop.name[1:]}\n") + else: + out.emit(f"#define {uop.name} {next_id}\n") + next_id += 1 + + out.emit(f"#define MAX_UOP_ID {next_id-1}\n") arg_parser = argparse.ArgumentParser( From 33357d0f2ddb0857e62d9b9982027f565d7e1423 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Wed, 13 Dec 2023 23:40:24 +0000 Subject: [PATCH 02/51] Reduce diff --- Include/internal/pycore_opcode_metadata.h | 54 +- Include/internal/pycore_uop_metadata.h | 550 ++++++++++++++++++ .../opcode_metadata_generator.py | 209 +++++++ .../cases_generator/uop_metadata_generator.py | 88 +++ 4 files changed, 877 insertions(+), 24 deletions(-) create mode 100644 Include/internal/pycore_uop_metadata.h create mode 100644 Tools/cases_generator/opcode_metadata_generator.py create mode 100644 Tools/cases_generator/uop_metadata_generator.py diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 04cc8ce38c614d..1b7398811ed539 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -9,27 +9,10 @@ extern "C" { #endif -#include // bool +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#include // bool #include "opcode_ids.h" -#include "pycore_uops.h" -#define HAS_ARG_FLAG (1) -#define HAS_CONST_FLAG (2) -#define HAS_ERROR_FLAG (4) -#define HAS_NAME_FLAG (8) -#define HAS_FREE_FLAG (16) -#define HAS_JUMP_FLAG (32) -#define HAS_DEOPT_FLAG (64) -#define HAS_ESCAPES_FLAG (128) -#define HAS_LOCAL_FLAG (256) -#define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) -#define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) -#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) -#define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) -#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) -#define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) -#define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) -#define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) -#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) #define IS_PSEUDO_INSTR(OP) ( \ @@ -47,6 +30,7 @@ extern "C" { ((OP) == POP_BLOCK) || \ 0) +#include "pycore_uops.h" enum InstructionFormat { INSTR_FMT_IB = 1, INSTR_FMT_IBC = 2, @@ -59,6 +43,30 @@ enum InstructionFormat { INSTR_FMT_IXC000 = 9, }; +#define IS_VALID_OPCODE(OP) \ + (((OP) >= 0) && ((OP) < 256) && \ + (_PyOpcode_opcode_metadata[(OP)].valid_entry)) + +#define HAS_ARG_FLAG (1) +#define HAS_CONST_FLAG (2) +#define HAS_ERROR_FLAG (4) +#define HAS_NAME_FLAG (8) +#define HAS_FREE_FLAG (16) +#define HAS_JUMP_FLAG (32) +#define HAS_DEOPT_FLAG (64) +#define HAS_ESCAPES_FLAG (128) +#define HAS_LOCAL_FLAG (256) +#define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) +#define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) +#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) +#define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) +#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) +#define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) +#define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) +#define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) +#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) +extern const uint8_t _PyOpcode_Deopt[256]; +#ifdef NEED_OPCODE_METADATA const uint8_t _PyOpcode_Deopt[256] = { [NOP] = NOP, [RESUME] = RESUME, @@ -269,6 +277,7 @@ const uint8_t _PyOpcode_Deopt[256] = { [BINARY_OP] = BINARY_OP, }; +#endif // NEED_OPCODE_METADATA const uint8_t _PyOpcode_Caches[256] = { [TO_BOOL_BOOL] = 3, [TO_BOOL_INT] = 3, @@ -583,10 +592,6 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, }; -#define IS_VALID_OPCODE(OP) \ - (((OP) >= 0) && ((OP) < 256) && \ - (_PyOpcode_opcode_metadata[(OP)].valid_entry)) - const char *_PyOpcode_OpName[268] = { [BEFORE_ASYNC_WITH] = "BEFORE_ASYNC_WITH", [BEFORE_WITH] = "BEFORE_WITH", @@ -841,6 +846,7 @@ is_pseudo_target(int pseudo, int target) { return false; } +#endif // Py_BUILD_CORE #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h new file mode 100644 index 00000000000000..0b8629669f73d0 --- /dev/null +++ b/Include/internal/pycore_uop_metadata.h @@ -0,0 +1,550 @@ +// This file is generated by Tools/cases_generator/uop_metadata_generator.py +// from: +// Python/bytecodes.c +// Do not edit! + +#ifndef Py_CORE_UOP_METADATA_H +#define Py_CORE_UOP_METADATA_H +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include "pycore_uop_ids.h" +extern const uint16_t _PyUop_Flags[MAX_UOP_ID+1]; +extern const char * const _PyOpcode_uop_name[MAX_UOP_ID+1]; + +#ifdef NEED_OPCODE_METADATA +const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { + [_NOP] = 0, + [_RESUME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_RESUME_CHECK] = HAS_DEOPT_FLAG, + [_INSTRUMENTED_RESUME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_FAST_CHECK] = HAS_ERROR_FLAG, + [_LOAD_FAST] = 0, + [_LOAD_FAST_AND_CLEAR] = 0, + [_LOAD_FAST_LOAD_FAST] = 0, + [_LOAD_CONST] = HAS_CONST_FLAG, + [_STORE_FAST] = 0, + [_STORE_FAST_LOAD_FAST] = 0, + [_STORE_FAST_STORE_FAST] = 0, + [_POP_TOP] = 0, + [_PUSH_NULL] = 0, + [_INSTRUMENTED_END_FOR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_END_SEND] = 0, + [_INSTRUMENTED_END_SEND] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_UNARY_NEGATIVE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_UNARY_NOT] = 0, + [_SPECIALIZE_TO_BOOL] = HAS_ESCAPES_FLAG, + [_TO_BOOL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_TO_BOOL_BOOL] = HAS_DEOPT_FLAG, + [_TO_BOOL_INT] = HAS_DEOPT_FLAG, + [_TO_BOOL_LIST] = HAS_DEOPT_FLAG, + [_TO_BOOL_NONE] = HAS_DEOPT_FLAG, + [_TO_BOOL_STR] = HAS_DEOPT_FLAG, + [_TO_BOOL_ALWAYS_TRUE] = HAS_DEOPT_FLAG, + [_UNARY_INVERT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_GUARD_BOTH_INT] = HAS_DEOPT_FLAG, + [_BINARY_OP_MULTIPLY_INT] = HAS_ERROR_FLAG, + [_BINARY_OP_ADD_INT] = HAS_ERROR_FLAG, + [_BINARY_OP_SUBTRACT_INT] = HAS_ERROR_FLAG, + [_GUARD_BOTH_FLOAT] = HAS_DEOPT_FLAG, + [_BINARY_OP_MULTIPLY_FLOAT] = 0, + [_BINARY_OP_ADD_FLOAT] = 0, + [_BINARY_OP_SUBTRACT_FLOAT] = 0, + [_GUARD_BOTH_UNICODE] = HAS_DEOPT_FLAG, + [_BINARY_OP_ADD_UNICODE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_SPECIALIZE_BINARY_SUBSCR] = HAS_ESCAPES_FLAG, + [_BINARY_SUBSCR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BINARY_SLICE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_STORE_SLICE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BINARY_SUBSCR_LIST_INT] = HAS_DEOPT_FLAG, + [_BINARY_SUBSCR_STR_INT] = HAS_DEOPT_FLAG, + [_BINARY_SUBSCR_TUPLE_INT] = HAS_DEOPT_FLAG, + [_BINARY_SUBSCR_DICT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_BINARY_SUBSCR_GETITEM] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_LIST_APPEND] = HAS_ERROR_FLAG, + [_SET_ADD] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SPECIALIZE_STORE_SUBSCR] = HAS_ESCAPES_FLAG, + [_STORE_SUBSCR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_STORE_SUBSCR_LIST_INT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_STORE_SUBSCR_DICT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_DELETE_SUBSCR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CALL_INTRINSIC_1] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CALL_INTRINSIC_2] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_RAISE_VARARGS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_INTERPRETER_EXIT] = HAS_ESCAPES_FLAG, + [_POP_FRAME] = HAS_ESCAPES_FLAG, + [_INSTRUMENTED_RETURN_VALUE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_INSTRUMENTED_RETURN_CONST] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_CONST_FLAG, + [_GET_AITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_GET_ANEXT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_GET_AWAITABLE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SPECIALIZE_SEND] = HAS_ESCAPES_FLAG, + [_SEND] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG, + [_SEND_GEN] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_INSTRUMENTED_YIELD_VALUE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_YIELD_VALUE] = HAS_ESCAPES_FLAG, + [_POP_EXCEPT] = HAS_ESCAPES_FLAG, + [_RERAISE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_END_ASYNC_FOR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CLEANUP_THROW] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_ASSERTION_ERROR] = 0, + [_LOAD_BUILD_CLASS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_STORE_NAME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_DELETE_NAME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SPECIALIZE_UNPACK_SEQUENCE] = HAS_ESCAPES_FLAG, + [_UNPACK_SEQUENCE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_UNPACK_SEQUENCE_TWO_TUPLE] = HAS_DEOPT_FLAG, + [_UNPACK_SEQUENCE_TUPLE] = HAS_DEOPT_FLAG, + [_UNPACK_SEQUENCE_LIST] = HAS_DEOPT_FLAG, + [_UNPACK_EX] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SPECIALIZE_STORE_ATTR] = HAS_ESCAPES_FLAG, + [_STORE_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_DELETE_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_STORE_GLOBAL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_DELETE_GLOBAL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_LOCALS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_FROM_DICT_OR_GLOBALS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_NAME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SPECIALIZE_LOAD_GLOBAL] = HAS_ESCAPES_FLAG, + [_LOAD_GLOBAL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_GUARD_GLOBALS_VERSION] = HAS_DEOPT_FLAG, + [_GUARD_BUILTINS_VERSION] = HAS_DEOPT_FLAG, + [_LOAD_GLOBAL_MODULE] = HAS_DEOPT_FLAG, + [_LOAD_GLOBAL_BUILTINS] = HAS_DEOPT_FLAG, + [_DELETE_FAST] = HAS_ERROR_FLAG, + [_MAKE_CELL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_DELETE_DEREF] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_FROM_DICT_OR_DEREF] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_DEREF] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_STORE_DEREF] = HAS_ESCAPES_FLAG, + [_COPY_FREE_VARS] = 0, + [_BUILD_STRING] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BUILD_TUPLE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BUILD_LIST] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LIST_EXTEND] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SET_UPDATE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BUILD_SET] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BUILD_MAP] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SETUP_ANNOTATIONS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BUILD_CONST_KEY_MAP] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_DICT_UPDATE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_DICT_MERGE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_MAP_ADD] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_INSTRUMENTED_LOAD_SUPER_ATTR] = 0, + [_SPECIALIZE_LOAD_SUPER_ATTR] = HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_SUPER_ATTR_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_LOAD_SUPER_ATTR_METHOD] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_SPECIALIZE_LOAD_ATTR] = HAS_ESCAPES_FLAG, + [_LOAD_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_GUARD_TYPE_VERSION] = HAS_DEOPT_FLAG, + [_CHECK_MANAGED_OBJECT_HAS_VALUES] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_INSTANCE_VALUE] = HAS_DEOPT_FLAG, + [_CHECK_ATTR_MODULE] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_MODULE] = HAS_DEOPT_FLAG, + [_CHECK_ATTR_WITH_HINT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_LOAD_ATTR_WITH_HINT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_LOAD_ATTR_SLOT] = HAS_DEOPT_FLAG, + [_CHECK_ATTR_CLASS] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_CLASS] = 0, + [_LOAD_ATTR_PROPERTY] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_GUARD_DORV_VALUES] = HAS_DEOPT_FLAG, + [_STORE_ATTR_INSTANCE_VALUE] = HAS_ESCAPES_FLAG, + [_STORE_ATTR_WITH_HINT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_STORE_ATTR_SLOT] = HAS_ESCAPES_FLAG, + [_SPECIALIZE_COMPARE_OP] = HAS_ESCAPES_FLAG, + [_COMPARE_OP] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_COMPARE_OP_FLOAT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_COMPARE_OP_INT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_COMPARE_OP_STR] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_IS_OP] = 0, + [_CONTAINS_OP] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CHECK_EG_MATCH] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CHECK_EXC_MATCH] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_IMPORT_NAME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_IMPORT_FROM] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_JUMP_FORWARD] = HAS_JUMP_FLAG, + [_JUMP_BACKWARD] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG, + [_ENTER_EXECUTOR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_POP_JUMP_IF_FALSE] = HAS_JUMP_FLAG, + [_POP_JUMP_IF_TRUE] = HAS_JUMP_FLAG, + [_IS_NONE] = 0, + [_JUMP_BACKWARD_NO_INTERRUPT] = HAS_JUMP_FLAG, + [_GET_LEN] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_MATCH_CLASS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_MATCH_MAPPING] = 0, + [_MATCH_SEQUENCE] = 0, + [_MATCH_KEYS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_GET_ITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_GET_YIELD_FROM_ITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SPECIALIZE_FOR_ITER] = HAS_ESCAPES_FLAG, + [_FOR_ITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG, + [_FOR_ITER_TIER_TWO] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_INSTRUMENTED_FOR_ITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_ITER_CHECK_LIST] = HAS_DEOPT_FLAG, + [_ITER_JUMP_LIST] = HAS_JUMP_FLAG, + [_GUARD_NOT_EXHAUSTED_LIST] = HAS_DEOPT_FLAG, + [_ITER_NEXT_LIST] = 0, + [_ITER_CHECK_TUPLE] = HAS_DEOPT_FLAG, + [_ITER_JUMP_TUPLE] = HAS_JUMP_FLAG, + [_GUARD_NOT_EXHAUSTED_TUPLE] = HAS_DEOPT_FLAG, + [_ITER_NEXT_TUPLE] = 0, + [_ITER_CHECK_RANGE] = HAS_DEOPT_FLAG, + [_ITER_JUMP_RANGE] = HAS_JUMP_FLAG, + [_GUARD_NOT_EXHAUSTED_RANGE] = HAS_DEOPT_FLAG, + [_ITER_NEXT_RANGE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_FOR_ITER_GEN] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_BEFORE_ASYNC_WITH] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BEFORE_WITH] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_WITH_EXCEPT_START] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_PUSH_EXC_INFO] = 0, + [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = HAS_DEOPT_FLAG, + [_GUARD_KEYS_VERSION] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_METHOD_WITH_VALUES] = HAS_ESCAPES_FLAG, + [_LOAD_ATTR_METHOD_NO_DICT] = HAS_ESCAPES_FLAG, + [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = 0, + [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = 0, + [_CHECK_ATTR_METHOD_LAZY_DICT] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ESCAPES_FLAG, + [_INSTRUMENTED_CALL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SPECIALIZE_CALL] = HAS_ESCAPES_FLAG, + [_CALL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = HAS_DEOPT_FLAG, + [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = 0, + [_CHECK_PEP_523] = HAS_DEOPT_FLAG, + [_CHECK_FUNCTION_EXACT_ARGS] = HAS_DEOPT_FLAG, + [_CHECK_STACK_SPACE] = HAS_DEOPT_FLAG, + [_INIT_CALL_PY_EXACT_ARGS] = HAS_ESCAPES_FLAG, + [_PUSH_FRAME] = 0, + [_CALL_PY_WITH_DEFAULTS] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_CALL_TYPE_1] = HAS_DEOPT_FLAG, + [_CALL_STR_1] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_TUPLE_1] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_ALLOC_AND_ENTER_INIT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_EXIT_INIT_CHECK] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CALL_BUILTIN_CLASS] = HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_BUILTIN_O] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_BUILTIN_FAST] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_LEN] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_ISINSTANCE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_LIST_APPEND] = HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_METHOD_DESCRIPTOR_O] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_INSTRUMENTED_CALL_KW] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CALL_KW] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_INSTRUMENTED_CALL_FUNCTION_EX] = 0, + [_CALL_FUNCTION_EX] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_MAKE_FUNCTION] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_SET_FUNCTION_ATTRIBUTE] = HAS_ESCAPES_FLAG, + [_RETURN_GENERATOR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BUILD_SLICE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CONVERT_VALUE] = HAS_ERROR_FLAG, + [_FORMAT_SIMPLE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_FORMAT_WITH_SPEC] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_COPY] = 0, + [_SPECIALIZE_BINARY_OP] = HAS_ESCAPES_FLAG, + [_BINARY_OP] = HAS_ERROR_FLAG, + [_SWAP] = 0, + [_INSTRUMENTED_INSTRUCTION] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_INSTRUMENTED_JUMP_FORWARD] = 0, + [_INSTRUMENTED_JUMP_BACKWARD] = 0, + [_INSTRUMENTED_POP_JUMP_IF_TRUE] = 0, + [_INSTRUMENTED_POP_JUMP_IF_FALSE] = 0, + [_INSTRUMENTED_POP_JUMP_IF_NONE] = 0, + [_INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = 0, + [_EXTENDED_ARG] = 0, + [_CACHE] = HAS_ESCAPES_FLAG, + [_RESERVED] = HAS_ESCAPES_FLAG, + [_GUARD_IS_TRUE_POP] = HAS_DEOPT_FLAG, + [_GUARD_IS_FALSE_POP] = HAS_DEOPT_FLAG, + [_GUARD_IS_NONE_POP] = HAS_DEOPT_FLAG, + [_GUARD_IS_NOT_NONE_POP] = HAS_DEOPT_FLAG, + [_JUMP_TO_TOP] = 0, + [_SET_IP] = HAS_ESCAPES_FLAG, + [_SAVE_RETURN_OFFSET] = 0, + [_EXIT_TRACE] = HAS_DEOPT_FLAG, + [_INSERT] = 0, + [_CHECK_VALIDITY] = HAS_DEOPT_FLAG, +}; + +const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { + [_BEFORE_ASYNC_WITH] = "_BEFORE_ASYNC_WITH", + [_BEFORE_WITH] = "_BEFORE_WITH", + [_BINARY_OP] = "_BINARY_OP", + [_BINARY_OP_ADD_FLOAT] = "_BINARY_OP_ADD_FLOAT", + [_BINARY_OP_ADD_INT] = "_BINARY_OP_ADD_INT", + [_BINARY_OP_ADD_UNICODE] = "_BINARY_OP_ADD_UNICODE", + [_BINARY_OP_INPLACE_ADD_UNICODE] = "_BINARY_OP_INPLACE_ADD_UNICODE", + [_BINARY_OP_MULTIPLY_FLOAT] = "_BINARY_OP_MULTIPLY_FLOAT", + [_BINARY_OP_MULTIPLY_INT] = "_BINARY_OP_MULTIPLY_INT", + [_BINARY_OP_SUBTRACT_FLOAT] = "_BINARY_OP_SUBTRACT_FLOAT", + [_BINARY_OP_SUBTRACT_INT] = "_BINARY_OP_SUBTRACT_INT", + [_BINARY_SLICE] = "_BINARY_SLICE", + [_BINARY_SUBSCR] = "_BINARY_SUBSCR", + [_BINARY_SUBSCR_DICT] = "_BINARY_SUBSCR_DICT", + [_BINARY_SUBSCR_GETITEM] = "_BINARY_SUBSCR_GETITEM", + [_BINARY_SUBSCR_LIST_INT] = "_BINARY_SUBSCR_LIST_INT", + [_BINARY_SUBSCR_STR_INT] = "_BINARY_SUBSCR_STR_INT", + [_BINARY_SUBSCR_TUPLE_INT] = "_BINARY_SUBSCR_TUPLE_INT", + [_BUILD_CONST_KEY_MAP] = "_BUILD_CONST_KEY_MAP", + [_BUILD_LIST] = "_BUILD_LIST", + [_BUILD_MAP] = "_BUILD_MAP", + [_BUILD_SET] = "_BUILD_SET", + [_BUILD_SLICE] = "_BUILD_SLICE", + [_BUILD_STRING] = "_BUILD_STRING", + [_BUILD_TUPLE] = "_BUILD_TUPLE", + [_CACHE] = "_CACHE", + [_CALL] = "_CALL", + [_CALL_ALLOC_AND_ENTER_INIT] = "_CALL_ALLOC_AND_ENTER_INIT", + [_CALL_BUILTIN_CLASS] = "_CALL_BUILTIN_CLASS", + [_CALL_BUILTIN_FAST] = "_CALL_BUILTIN_FAST", + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = "_CALL_BUILTIN_FAST_WITH_KEYWORDS", + [_CALL_BUILTIN_O] = "_CALL_BUILTIN_O", + [_CALL_FUNCTION_EX] = "_CALL_FUNCTION_EX", + [_CALL_INTRINSIC_1] = "_CALL_INTRINSIC_1", + [_CALL_INTRINSIC_2] = "_CALL_INTRINSIC_2", + [_CALL_ISINSTANCE] = "_CALL_ISINSTANCE", + [_CALL_KW] = "_CALL_KW", + [_CALL_LEN] = "_CALL_LEN", + [_CALL_LIST_APPEND] = "_CALL_LIST_APPEND", + [_CALL_METHOD_DESCRIPTOR_FAST] = "_CALL_METHOD_DESCRIPTOR_FAST", + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = "_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", + [_CALL_METHOD_DESCRIPTOR_NOARGS] = "_CALL_METHOD_DESCRIPTOR_NOARGS", + [_CALL_METHOD_DESCRIPTOR_O] = "_CALL_METHOD_DESCRIPTOR_O", + [_CALL_PY_WITH_DEFAULTS] = "_CALL_PY_WITH_DEFAULTS", + [_CALL_STR_1] = "_CALL_STR_1", + [_CALL_TUPLE_1] = "_CALL_TUPLE_1", + [_CALL_TYPE_1] = "_CALL_TYPE_1", + [_CHECK_ATTR_CLASS] = "_CHECK_ATTR_CLASS", + [_CHECK_ATTR_METHOD_LAZY_DICT] = "_CHECK_ATTR_METHOD_LAZY_DICT", + [_CHECK_ATTR_MODULE] = "_CHECK_ATTR_MODULE", + [_CHECK_ATTR_WITH_HINT] = "_CHECK_ATTR_WITH_HINT", + [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = "_CHECK_CALL_BOUND_METHOD_EXACT_ARGS", + [_CHECK_EG_MATCH] = "_CHECK_EG_MATCH", + [_CHECK_EXC_MATCH] = "_CHECK_EXC_MATCH", + [_CHECK_FUNCTION_EXACT_ARGS] = "_CHECK_FUNCTION_EXACT_ARGS", + [_CHECK_MANAGED_OBJECT_HAS_VALUES] = "_CHECK_MANAGED_OBJECT_HAS_VALUES", + [_CHECK_PEP_523] = "_CHECK_PEP_523", + [_CHECK_STACK_SPACE] = "_CHECK_STACK_SPACE", + [_CHECK_VALIDITY] = "_CHECK_VALIDITY", + [_CLEANUP_THROW] = "_CLEANUP_THROW", + [_COMPARE_OP] = "_COMPARE_OP", + [_COMPARE_OP_FLOAT] = "_COMPARE_OP_FLOAT", + [_COMPARE_OP_INT] = "_COMPARE_OP_INT", + [_COMPARE_OP_STR] = "_COMPARE_OP_STR", + [_CONTAINS_OP] = "_CONTAINS_OP", + [_CONVERT_VALUE] = "_CONVERT_VALUE", + [_COPY] = "_COPY", + [_COPY_FREE_VARS] = "_COPY_FREE_VARS", + [_DELETE_ATTR] = "_DELETE_ATTR", + [_DELETE_DEREF] = "_DELETE_DEREF", + [_DELETE_FAST] = "_DELETE_FAST", + [_DELETE_GLOBAL] = "_DELETE_GLOBAL", + [_DELETE_NAME] = "_DELETE_NAME", + [_DELETE_SUBSCR] = "_DELETE_SUBSCR", + [_DICT_MERGE] = "_DICT_MERGE", + [_DICT_UPDATE] = "_DICT_UPDATE", + [_END_ASYNC_FOR] = "_END_ASYNC_FOR", + [_END_SEND] = "_END_SEND", + [_ENTER_EXECUTOR] = "_ENTER_EXECUTOR", + [_EXIT_INIT_CHECK] = "_EXIT_INIT_CHECK", + [_EXIT_TRACE] = "_EXIT_TRACE", + [_EXTENDED_ARG] = "_EXTENDED_ARG", + [_FORMAT_SIMPLE] = "_FORMAT_SIMPLE", + [_FORMAT_WITH_SPEC] = "_FORMAT_WITH_SPEC", + [_FOR_ITER] = "_FOR_ITER", + [_FOR_ITER_GEN] = "_FOR_ITER_GEN", + [_FOR_ITER_TIER_TWO] = "_FOR_ITER_TIER_TWO", + [_GET_AITER] = "_GET_AITER", + [_GET_ANEXT] = "_GET_ANEXT", + [_GET_AWAITABLE] = "_GET_AWAITABLE", + [_GET_ITER] = "_GET_ITER", + [_GET_LEN] = "_GET_LEN", + [_GET_YIELD_FROM_ITER] = "_GET_YIELD_FROM_ITER", + [_GUARD_BOTH_FLOAT] = "_GUARD_BOTH_FLOAT", + [_GUARD_BOTH_INT] = "_GUARD_BOTH_INT", + [_GUARD_BOTH_UNICODE] = "_GUARD_BOTH_UNICODE", + [_GUARD_BUILTINS_VERSION] = "_GUARD_BUILTINS_VERSION", + [_GUARD_DORV_VALUES] = "_GUARD_DORV_VALUES", + [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT", + [_GUARD_GLOBALS_VERSION] = "_GUARD_GLOBALS_VERSION", + [_GUARD_IS_FALSE_POP] = "_GUARD_IS_FALSE_POP", + [_GUARD_IS_NONE_POP] = "_GUARD_IS_NONE_POP", + [_GUARD_IS_NOT_NONE_POP] = "_GUARD_IS_NOT_NONE_POP", + [_GUARD_IS_TRUE_POP] = "_GUARD_IS_TRUE_POP", + [_GUARD_KEYS_VERSION] = "_GUARD_KEYS_VERSION", + [_GUARD_NOT_EXHAUSTED_LIST] = "_GUARD_NOT_EXHAUSTED_LIST", + [_GUARD_NOT_EXHAUSTED_RANGE] = "_GUARD_NOT_EXHAUSTED_RANGE", + [_GUARD_NOT_EXHAUSTED_TUPLE] = "_GUARD_NOT_EXHAUSTED_TUPLE", + [_GUARD_TYPE_VERSION] = "_GUARD_TYPE_VERSION", + [_IMPORT_FROM] = "_IMPORT_FROM", + [_IMPORT_NAME] = "_IMPORT_NAME", + [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = "_INIT_CALL_BOUND_METHOD_EXACT_ARGS", + [_INIT_CALL_PY_EXACT_ARGS] = "_INIT_CALL_PY_EXACT_ARGS", + [_INSERT] = "_INSERT", + [_INSTRUMENTED_CALL] = "_INSTRUMENTED_CALL", + [_INSTRUMENTED_CALL_FUNCTION_EX] = "_INSTRUMENTED_CALL_FUNCTION_EX", + [_INSTRUMENTED_CALL_KW] = "_INSTRUMENTED_CALL_KW", + [_INSTRUMENTED_END_FOR] = "_INSTRUMENTED_END_FOR", + [_INSTRUMENTED_END_SEND] = "_INSTRUMENTED_END_SEND", + [_INSTRUMENTED_FOR_ITER] = "_INSTRUMENTED_FOR_ITER", + [_INSTRUMENTED_INSTRUCTION] = "_INSTRUMENTED_INSTRUCTION", + [_INSTRUMENTED_JUMP_BACKWARD] = "_INSTRUMENTED_JUMP_BACKWARD", + [_INSTRUMENTED_JUMP_FORWARD] = "_INSTRUMENTED_JUMP_FORWARD", + [_INSTRUMENTED_LOAD_SUPER_ATTR] = "_INSTRUMENTED_LOAD_SUPER_ATTR", + [_INSTRUMENTED_POP_JUMP_IF_FALSE] = "_INSTRUMENTED_POP_JUMP_IF_FALSE", + [_INSTRUMENTED_POP_JUMP_IF_NONE] = "_INSTRUMENTED_POP_JUMP_IF_NONE", + [_INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = "_INSTRUMENTED_POP_JUMP_IF_NOT_NONE", + [_INSTRUMENTED_POP_JUMP_IF_TRUE] = "_INSTRUMENTED_POP_JUMP_IF_TRUE", + [_INSTRUMENTED_RESUME] = "_INSTRUMENTED_RESUME", + [_INSTRUMENTED_RETURN_CONST] = "_INSTRUMENTED_RETURN_CONST", + [_INSTRUMENTED_RETURN_VALUE] = "_INSTRUMENTED_RETURN_VALUE", + [_INSTRUMENTED_YIELD_VALUE] = "_INSTRUMENTED_YIELD_VALUE", + [_INTERPRETER_EXIT] = "_INTERPRETER_EXIT", + [_IS_NONE] = "_IS_NONE", + [_IS_OP] = "_IS_OP", + [_ITER_CHECK_LIST] = "_ITER_CHECK_LIST", + [_ITER_CHECK_RANGE] = "_ITER_CHECK_RANGE", + [_ITER_CHECK_TUPLE] = "_ITER_CHECK_TUPLE", + [_ITER_JUMP_LIST] = "_ITER_JUMP_LIST", + [_ITER_JUMP_RANGE] = "_ITER_JUMP_RANGE", + [_ITER_JUMP_TUPLE] = "_ITER_JUMP_TUPLE", + [_ITER_NEXT_LIST] = "_ITER_NEXT_LIST", + [_ITER_NEXT_RANGE] = "_ITER_NEXT_RANGE", + [_ITER_NEXT_TUPLE] = "_ITER_NEXT_TUPLE", + [_JUMP_BACKWARD] = "_JUMP_BACKWARD", + [_JUMP_BACKWARD_NO_INTERRUPT] = "_JUMP_BACKWARD_NO_INTERRUPT", + [_JUMP_FORWARD] = "_JUMP_FORWARD", + [_JUMP_TO_TOP] = "_JUMP_TO_TOP", + [_LIST_APPEND] = "_LIST_APPEND", + [_LIST_EXTEND] = "_LIST_EXTEND", + [_LOAD_ASSERTION_ERROR] = "_LOAD_ASSERTION_ERROR", + [_LOAD_ATTR] = "_LOAD_ATTR", + [_LOAD_ATTR_CLASS] = "_LOAD_ATTR_CLASS", + [_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = "_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN", + [_LOAD_ATTR_INSTANCE_VALUE] = "_LOAD_ATTR_INSTANCE_VALUE", + [_LOAD_ATTR_METHOD_LAZY_DICT] = "_LOAD_ATTR_METHOD_LAZY_DICT", + [_LOAD_ATTR_METHOD_NO_DICT] = "_LOAD_ATTR_METHOD_NO_DICT", + [_LOAD_ATTR_METHOD_WITH_VALUES] = "_LOAD_ATTR_METHOD_WITH_VALUES", + [_LOAD_ATTR_MODULE] = "_LOAD_ATTR_MODULE", + [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "_LOAD_ATTR_NONDESCRIPTOR_NO_DICT", + [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = "_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES", + [_LOAD_ATTR_PROPERTY] = "_LOAD_ATTR_PROPERTY", + [_LOAD_ATTR_SLOT] = "_LOAD_ATTR_SLOT", + [_LOAD_ATTR_WITH_HINT] = "_LOAD_ATTR_WITH_HINT", + [_LOAD_BUILD_CLASS] = "_LOAD_BUILD_CLASS", + [_LOAD_CONST] = "_LOAD_CONST", + [_LOAD_DEREF] = "_LOAD_DEREF", + [_LOAD_FAST] = "_LOAD_FAST", + [_LOAD_FAST_AND_CLEAR] = "_LOAD_FAST_AND_CLEAR", + [_LOAD_FAST_CHECK] = "_LOAD_FAST_CHECK", + [_LOAD_FAST_LOAD_FAST] = "_LOAD_FAST_LOAD_FAST", + [_LOAD_FROM_DICT_OR_DEREF] = "_LOAD_FROM_DICT_OR_DEREF", + [_LOAD_FROM_DICT_OR_GLOBALS] = "_LOAD_FROM_DICT_OR_GLOBALS", + [_LOAD_GLOBAL] = "_LOAD_GLOBAL", + [_LOAD_GLOBAL_BUILTINS] = "_LOAD_GLOBAL_BUILTINS", + [_LOAD_GLOBAL_MODULE] = "_LOAD_GLOBAL_MODULE", + [_LOAD_LOCALS] = "_LOAD_LOCALS", + [_LOAD_NAME] = "_LOAD_NAME", + [_LOAD_SUPER_ATTR] = "_LOAD_SUPER_ATTR", + [_LOAD_SUPER_ATTR_ATTR] = "_LOAD_SUPER_ATTR_ATTR", + [_LOAD_SUPER_ATTR_METHOD] = "_LOAD_SUPER_ATTR_METHOD", + [_MAKE_CELL] = "_MAKE_CELL", + [_MAKE_FUNCTION] = "_MAKE_FUNCTION", + [_MAP_ADD] = "_MAP_ADD", + [_MATCH_CLASS] = "_MATCH_CLASS", + [_MATCH_KEYS] = "_MATCH_KEYS", + [_MATCH_MAPPING] = "_MATCH_MAPPING", + [_MATCH_SEQUENCE] = "_MATCH_SEQUENCE", + [_NOP] = "_NOP", + [_POP_EXCEPT] = "_POP_EXCEPT", + [_POP_FRAME] = "_POP_FRAME", + [_POP_JUMP_IF_FALSE] = "_POP_JUMP_IF_FALSE", + [_POP_JUMP_IF_TRUE] = "_POP_JUMP_IF_TRUE", + [_POP_TOP] = "_POP_TOP", + [_PUSH_EXC_INFO] = "_PUSH_EXC_INFO", + [_PUSH_FRAME] = "_PUSH_FRAME", + [_PUSH_NULL] = "_PUSH_NULL", + [_RAISE_VARARGS] = "_RAISE_VARARGS", + [_RERAISE] = "_RERAISE", + [_RESERVED] = "_RESERVED", + [_RESUME] = "_RESUME", + [_RESUME_CHECK] = "_RESUME_CHECK", + [_RETURN_GENERATOR] = "_RETURN_GENERATOR", + [_SAVE_RETURN_OFFSET] = "_SAVE_RETURN_OFFSET", + [_SEND] = "_SEND", + [_SEND_GEN] = "_SEND_GEN", + [_SETUP_ANNOTATIONS] = "_SETUP_ANNOTATIONS", + [_SET_ADD] = "_SET_ADD", + [_SET_FUNCTION_ATTRIBUTE] = "_SET_FUNCTION_ATTRIBUTE", + [_SET_IP] = "_SET_IP", + [_SET_UPDATE] = "_SET_UPDATE", + [_SPECIALIZE_BINARY_OP] = "_SPECIALIZE_BINARY_OP", + [_SPECIALIZE_BINARY_SUBSCR] = "_SPECIALIZE_BINARY_SUBSCR", + [_SPECIALIZE_CALL] = "_SPECIALIZE_CALL", + [_SPECIALIZE_COMPARE_OP] = "_SPECIALIZE_COMPARE_OP", + [_SPECIALIZE_FOR_ITER] = "_SPECIALIZE_FOR_ITER", + [_SPECIALIZE_LOAD_ATTR] = "_SPECIALIZE_LOAD_ATTR", + [_SPECIALIZE_LOAD_GLOBAL] = "_SPECIALIZE_LOAD_GLOBAL", + [_SPECIALIZE_LOAD_SUPER_ATTR] = "_SPECIALIZE_LOAD_SUPER_ATTR", + [_SPECIALIZE_SEND] = "_SPECIALIZE_SEND", + [_SPECIALIZE_STORE_ATTR] = "_SPECIALIZE_STORE_ATTR", + [_SPECIALIZE_STORE_SUBSCR] = "_SPECIALIZE_STORE_SUBSCR", + [_SPECIALIZE_TO_BOOL] = "_SPECIALIZE_TO_BOOL", + [_SPECIALIZE_UNPACK_SEQUENCE] = "_SPECIALIZE_UNPACK_SEQUENCE", + [_STORE_ATTR] = "_STORE_ATTR", + [_STORE_ATTR_INSTANCE_VALUE] = "_STORE_ATTR_INSTANCE_VALUE", + [_STORE_ATTR_SLOT] = "_STORE_ATTR_SLOT", + [_STORE_ATTR_WITH_HINT] = "_STORE_ATTR_WITH_HINT", + [_STORE_DEREF] = "_STORE_DEREF", + [_STORE_FAST] = "_STORE_FAST", + [_STORE_FAST_LOAD_FAST] = "_STORE_FAST_LOAD_FAST", + [_STORE_FAST_STORE_FAST] = "_STORE_FAST_STORE_FAST", + [_STORE_GLOBAL] = "_STORE_GLOBAL", + [_STORE_NAME] = "_STORE_NAME", + [_STORE_SLICE] = "_STORE_SLICE", + [_STORE_SUBSCR] = "_STORE_SUBSCR", + [_STORE_SUBSCR_DICT] = "_STORE_SUBSCR_DICT", + [_STORE_SUBSCR_LIST_INT] = "_STORE_SUBSCR_LIST_INT", + [_SWAP] = "_SWAP", + [_TO_BOOL] = "_TO_BOOL", + [_TO_BOOL_ALWAYS_TRUE] = "_TO_BOOL_ALWAYS_TRUE", + [_TO_BOOL_BOOL] = "_TO_BOOL_BOOL", + [_TO_BOOL_INT] = "_TO_BOOL_INT", + [_TO_BOOL_LIST] = "_TO_BOOL_LIST", + [_TO_BOOL_NONE] = "_TO_BOOL_NONE", + [_TO_BOOL_STR] = "_TO_BOOL_STR", + [_UNARY_INVERT] = "_UNARY_INVERT", + [_UNARY_NEGATIVE] = "_UNARY_NEGATIVE", + [_UNARY_NOT] = "_UNARY_NOT", + [_UNPACK_EX] = "_UNPACK_EX", + [_UNPACK_SEQUENCE] = "_UNPACK_SEQUENCE", + [_UNPACK_SEQUENCE_LIST] = "_UNPACK_SEQUENCE_LIST", + [_UNPACK_SEQUENCE_TUPLE] = "_UNPACK_SEQUENCE_TUPLE", + [_UNPACK_SEQUENCE_TWO_TUPLE] = "_UNPACK_SEQUENCE_TWO_TUPLE", + [_WITH_EXCEPT_START] = "_WITH_EXCEPT_START", + [_YIELD_VALUE] = "_YIELD_VALUE", +}; +#endif // NEED_OPCODE_METADATA + +extern const struct opcode_macro_expansion +_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE]; + +#ifdef NEED_OPCODE_METADATA +const struct opcode_macro_expansion +_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE] = { +}; +#endif // NEED_OPCODE_METADATA + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_CORE_UOP_METADATA_H */ diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py new file mode 100644 index 00000000000000..8ff961376ede94 --- /dev/null +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -0,0 +1,209 @@ +"""Generate uop metedata. +Reads the instruction definitions from bytecodes.c. +Writes the metadata to pycore_uop_metadata.h by default. +""" + +import argparse +import os.path +import sys + +from analyzer import ( + Analysis, + Instruction, + analyze_files, + Skip, +) +from generators_common import ( + DEFAULT_INPUT, + ROOT, + write_header, + cflags, + StackOffset, +) +from cwriter import CWriter +from typing import TextIO + + +DEFAULT_OUTPUT = ROOT / "Include/internal/pycore_uop_metadata.h" + +FLAGS = [ + "ARG", + "CONST", + "ERROR", + "NAME", + "FREE", + "JUMP", + "DEOPT", + "ESCAPES", + "LOCAL", +] + +def generate_flag_macros(out: CWriter) -> None: + for i, flag in enumerate(FLAGS): + out.emit(f"#define HAS_{flag}_FLAG ({1< None: + """Write the IS_PSEUDO_INSTR macro""" + out.emit("\n\n#define IS_PSEUDO_INSTR(OP) ( \\\n") + for op in analysis.pseudos: + out.emit(f"((OP) == {op}) || \\\n") + out.emit("0") + out.emit(")\n\n") + + +def get_format(inst: Instruction) -> str: + if inst.properties.oparg: + format = "INSTR_FMT_IB" + else: + format = "INSTR_FMT_IX" + if inst.size > 1: + format += "C" + format += "0" * (inst.size-2) + return format + + +def generate_instruction_formats( + analysis: Analysis, out: CWriter +) -> None: + # Compute the set of all instruction formats. + formats: set[str] = set() + for inst in analysis.instructions.values(): + formats.add(get_format(inst)) + out.emit("enum InstructionFormat {\n") + next_id = 1 + for format in sorted(formats): + out.emit(f"{format} = {next_id},\n") + next_id += 1 + out.emit("};\n\n") + + +def generate_deopt_table( + analysis: Analysis, out: CWriter +) -> None: + out.emit("extern const uint8_t _PyOpcode_Deopt[256];\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") + out.emit("const uint8_t _PyOpcode_Deopt[256] = {\n") + for inst in analysis.instructions.values(): + deopt = inst.name + if inst.family is not None: + deopt = inst.family.name + out.emit(f"[{inst.name}] = {deopt},\n") + out.emit("};\n\n") + out.emit("#endif // NEED_OPCODE_METADATA\n") + + +def generate_cache_table( + analysis: Analysis, out: CWriter +) -> None: + out.emit("const uint8_t _PyOpcode_Caches[256] = {\n") + for inst in analysis.instructions.values(): + if inst.size > 1: + out.emit(f"[{inst.name}] = {inst.size-1},\n") + out.emit("};\n\n") + + +def generate_name_table( + analysis: Analysis, out: CWriter +) -> None: + table_size = 256 + len(analysis.pseudos) + out.emit(f"const char *_PyOpcode_OpName[{table_size}] = {{\n") + names = list(analysis.instructions) + list(analysis.pseudos) + for name in sorted(names): + out.emit(f'[{name}] = "{name}",\n') + out.emit("};\n\n") + + +def generate_metadata_table( + analysis: Analysis, out: CWriter +) -> None: + out.emit("struct opcode_metadata {\n") + out.emit("uint8_t valid_entry;\n"); + out.emit("uint8_t instr_format;\n"); + out.emit("uint16_t flags;\n"); + out.emit("};\n\n") + out.emit("const struct opcode_metadata _PyOpcode_opcode_metadata[256] = {\n") + for inst in analysis.instructions.values(): + out.emit(f"[{inst.name}] = {{ true, {get_format(inst)}, {cflags(inst.properties)} }},\n") + out.emit("};\n\n") + + +def generate_psuedo_targets( + analysis: Analysis, out: CWriter +) -> None: + table_size = len(analysis.pseudos) + max_targets = max(len(pseudo.targets) for pseudo in analysis.pseudos.values()) + out.emit("struct pseudo_targets {\n") + out.emit(f"uint8_t targets[{max_targets + 1}];\n") + out.emit("};\n") + out.emit(f"const struct pseudo_targets pseudo_targets[{table_size}];\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") + out.emit(f"const struct pseudo_targets pseudo_targets[{table_size}] = {{\n") + for pseudo in analysis.pseudos.values(): + targets = [ "0" ] * (max_targets + 1) + for i, target in enumerate(pseudo.targets): + targets[i] = target.name + out.emit(f"[{pseudo.name}-256] = {{ {{ {", ".join(targets)} }} }},\n") + out.emit("};\n\n") + out.emit("#endif // NEED_OPCODE_METADATA\n") + out.emit("static inline bool\n") + out.emit("is_pseudo_target(int pseudo, int target) {\n") + out.emit(f"if (pseudo < 256 || pseudo >= {256+table_size}) {{\n") + out.emit(f"return false;\n") + out.emit("}\n") + out.emit(f"for (int i = 0; pseudo_targets[pseudo-256].targets[i]; i++) {{\n") + out.emit(f"if (pseudo_targets[pseudo-256].targets[i] == target) return true;\n") + out.emit("}\n") + out.emit(f"return false;\n") + out.emit("}\n\n") + + +def generate_opcode_metadata( + filenames: list[str], analysis: Analysis, outfile: TextIO +) -> None: + write_header(__file__, filenames, outfile) + out = CWriter(outfile, 0, False) + with out.header_guard("Py_CORE_OPCODE_METADATA_H"): + out.emit("#ifndef Py_BUILD_CORE\n") + out.emit('# error "this header requires Py_BUILD_CORE define"\n') + out.emit("#include // bool\n") + out.emit('#include "opcode_ids.h"\n') + generate_is_pseudo(analysis, out) + out.emit('#include "pycore_uops.h"\n') + generate_instruction_formats(analysis, out) + out.emit("#define IS_VALID_OPCODE(OP) \\\n") + out.emit(" (((OP) >= 0) && ((OP) < 256) && \\\n") + out.emit(" (_PyOpcode_opcode_metadata[(OP)].valid_entry))\n\n") + generate_flag_macros(out) + generate_deopt_table(analysis, out) + generate_cache_table(analysis, out) + generate_metadata_table(analysis, out) + generate_name_table(analysis, out) + generate_psuedo_targets(analysis, out) + out.emit("#endif // Py_BUILD_CORE\n") + + +arg_parser = argparse.ArgumentParser( + description="Generate the header file with opcode metadata.", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, +) + +arg_parser.add_argument( + "-o", "--output", type=str, help="Generated code", default=DEFAULT_OUTPUT +) + +arg_parser.add_argument( + "input", nargs=argparse.REMAINDER, help="Instruction definition file(s)" +) + +if __name__ == "__main__": + args = arg_parser.parse_args() + if len(args.input) == 0: + args.input.append(DEFAULT_INPUT) + data = analyze_files(args.input) + with open(args.output, "w") as outfile: + generate_opcode_metadata(args.input, data, outfile) diff --git a/Tools/cases_generator/uop_metadata_generator.py b/Tools/cases_generator/uop_metadata_generator.py new file mode 100644 index 00000000000000..9daf58df7f00ed --- /dev/null +++ b/Tools/cases_generator/uop_metadata_generator.py @@ -0,0 +1,88 @@ +"""Generate uop metedata. +Reads the instruction definitions from bytecodes.c. +Writes the metadata to pycore_uop_metadata.h by default. +""" + +import argparse +import os.path +import sys + +from analyzer import ( + Analysis, + Instruction, + analyze_files, +) +from generators_common import ( + DEFAULT_INPUT, + ROOT, + write_header, + cflags, +) +from cwriter import CWriter +from typing import TextIO + + +DEFAULT_OUTPUT = ROOT / "Include/internal/pycore_uop_metadata.h" + +def generate_names_and_flags( + analysis: Analysis, out: CWriter +) -> None: + out.emit("extern const uint16_t _PyUop_Flags[MAX_UOP_ID+1];\n") + out.emit("extern const char * const _PyOpcode_uop_name[MAX_UOP_ID+1];\n\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") + out.emit("const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = {\n") + for uop in analysis.uops.values(): + out.emit(f"[{uop.name}] = {cflags(uop.properties)},\n") + + out.emit("};\n\n") + out.emit("const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = {\n") + names = [uop.name for uop in analysis.uops.values()] + for name in sorted(names): + out.emit(f'[{name}] = "{name}",\n') + out.emit("};\n") + out.emit("#endif // NEED_OPCODE_METADATA\n\n") + +def generate_expansion_table( + analysis: Analysis, out: CWriter +) -> None: + out.emit("extern const struct opcode_macro_expansion\n") + out.emit("_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE];\n\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") + out.emit("const struct opcode_macro_expansion\n") + out.emit("_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE] = {\n") + + + out.emit("};\n") + out.emit("#endif // NEED_OPCODE_METADATA\n\n") + +def generate_uop_metadata( + filenames: list[str], analysis: Analysis, outfile: TextIO +) -> None: + write_header(__file__, filenames, outfile) + out = CWriter(outfile, 0, False) + with out.header_guard("Py_CORE_UOP_METADATA_H"): + out.emit('#include \n') + out.emit('#include "pycore_uop_ids.h"\n') + generate_names_and_flags(analysis, out) + generate_expansion_table(analysis, out) + +arg_parser = argparse.ArgumentParser( + description="Generate the header file with uop metadata.", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, +) + +arg_parser.add_argument( + "-o", "--output", type=str, help="Generated code", default=DEFAULT_OUTPUT +) + +arg_parser.add_argument( + "input", nargs=argparse.REMAINDER, help="Instruction definition file(s)" +) + +if __name__ == "__main__": + args = arg_parser.parse_args() + if len(args.input) == 0: + args.input.append(DEFAULT_INPUT) + data = analyze_files(args.input) + with open(args.output, "w") as outfile: + generate_uop_metadata(args.input, data, outfile) From 45218aab3e56623f557fe482d3d3a412f68567ca Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 02:16:28 +0000 Subject: [PATCH 03/51] Add expansion table --- Include/internal/pycore_opcode_metadata.h | 244 +++++++++++++++++- Include/internal/pycore_uop_metadata.h | 9 - Tools/cases_generator/analyzer.py | 16 +- .../opcode_metadata_generator.py | 76 +++++- Tools/cases_generator/tier2_generator.py | 9 +- .../cases_generator/uop_metadata_generator.py | 15 +- 6 files changed, 320 insertions(+), 49 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 1b7398811ed539..7c9a0a53398071 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -11,6 +11,7 @@ extern "C" { #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" +#endif #include // bool #include "opcode_ids.h" @@ -45,26 +46,26 @@ enum InstructionFormat { #define IS_VALID_OPCODE(OP) \ (((OP) >= 0) && ((OP) < 256) && \ - (_PyOpcode_opcode_metadata[(OP)].valid_entry)) + (_PyOpcode_opcode_metadata[(OP)].valid_entry)) #define HAS_ARG_FLAG (1) #define HAS_CONST_FLAG (2) -#define HAS_ERROR_FLAG (4) -#define HAS_NAME_FLAG (8) -#define HAS_FREE_FLAG (16) -#define HAS_JUMP_FLAG (32) -#define HAS_DEOPT_FLAG (64) -#define HAS_ESCAPES_FLAG (128) -#define HAS_LOCAL_FLAG (256) +#define HAS_NAME_FLAG (4) +#define HAS_JUMP_FLAG (8) +#define HAS_LOCAL_FLAG (16) +#define HAS_ERROR_FLAG (32) +#define HAS_FREE_FLAG (64) +#define HAS_DEOPT_FLAG (128) +#define HAS_ESCAPES_FLAG (256) #define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) #define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) -#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) #define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) -#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) #define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) +#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) +#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) +#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) #define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) #define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) -#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) extern const uint8_t _PyOpcode_Deopt[256]; #ifdef NEED_OPCODE_METADATA const uint8_t _PyOpcode_Deopt[256] = { @@ -592,6 +593,226 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, }; +#define MAX_UOP_PER_EXPANSION 9 +struct opcode_macro_expansion { + int nuops;struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION]; +}; +extern const struct opcode_macro_expansion +_PyOpcode_macro_expansion[256]; + +#ifdef NEED_OPCODE_METADATA +const struct opcode_macro_expansion +_PyOpcode_macro_expansion[256] = { + [BEFORE_ASYNC_WITH] = { .nops = 1, .uops = { { _BEFORE_ASYNC_WITH 0, 0 } }}, + [BEFORE_WITH] = { .nops = 1, .uops = { { _BEFORE_WITH 0, 0 } }}, + [BINARY_OP] = { .nops = 0, .uops = { }}, + [BINARY_OP_ADD_FLOAT] = { .nops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_ADD_FLOAT 1, 0 } }}, + [BINARY_OP_ADD_INT] = { .nops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_ADD_INT 1, 0 } }}, + [BINARY_OP_ADD_UNICODE] = { .nops = 2, .uops = { { _GUARD_BOTH_UNICODE 0, 0 }, { _BINARY_OP_ADD_UNICODE 1, 0 } }}, + [BINARY_OP_INPLACE_ADD_UNICODE] = { .nops = 2, .uops = { { _GUARD_BOTH_UNICODE 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE 1, 0 } }}, + [BINARY_OP_MULTIPLY_FLOAT] = { .nops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT 1, 0 } }}, + [BINARY_OP_MULTIPLY_INT] = { .nops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_MULTIPLY_INT 1, 0 } }}, + [BINARY_OP_SUBTRACT_FLOAT] = { .nops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT 1, 0 } }}, + [BINARY_OP_SUBTRACT_INT] = { .nops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_SUBTRACT_INT 1, 0 } }}, + [BINARY_SLICE] = { .nops = 1, .uops = { { _BINARY_SLICE 0, 0 } }}, + [BINARY_SUBSCR] = { .nops = 0, .uops = { }}, + [BINARY_SUBSCR_DICT] = { .nops = 1, .uops = { { _BINARY_SUBSCR_DICT 1, 0 } }}, + [BINARY_SUBSCR_GETITEM] = { .nops = 0, .uops = { }}, + [BINARY_SUBSCR_LIST_INT] = { .nops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT 1, 0 } }}, + [BINARY_SUBSCR_STR_INT] = { .nops = 1, .uops = { { _BINARY_SUBSCR_STR_INT 1, 0 } }}, + [BINARY_SUBSCR_TUPLE_INT] = { .nops = 1, .uops = { { _BINARY_SUBSCR_TUPLE_INT 1, 0 } }}, + [BUILD_CONST_KEY_MAP] = { .nops = 1, .uops = { { _BUILD_CONST_KEY_MAP 0, 0 } }}, + [BUILD_LIST] = { .nops = 1, .uops = { { _BUILD_LIST 0, 0 } }}, + [BUILD_MAP] = { .nops = 1, .uops = { { _BUILD_MAP 0, 0 } }}, + [BUILD_SET] = { .nops = 1, .uops = { { _BUILD_SET 0, 0 } }}, + [BUILD_SLICE] = { .nops = 1, .uops = { { _BUILD_SLICE 0, 0 } }}, + [BUILD_STRING] = { .nops = 1, .uops = { { _BUILD_STRING 0, 0 } }}, + [BUILD_TUPLE] = { .nops = 1, .uops = { { _BUILD_TUPLE 0, 0 } }}, + [CACHE] = { .nops = 1, .uops = { { _CACHE 0, 0 } }}, + [CALL] = { .nops = 0, .uops = { }}, + [CALL_ALLOC_AND_ENTER_INIT] = { .nops = 0, .uops = { }}, + [CALL_BOUND_METHOD_EXACT_ARGS] = { .nops = 9, .uops = { { unused/1 1, 0 }, { _CHECK_PEP_523 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS 2, 1 }, { _CHECK_STACK_SPACE 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS 0, 0 }, { _SAVE_RETURN_OFFSET 7, 3 }, { _PUSH_FRAME 0, 0 } }}, + [CALL_BUILTIN_CLASS] = { .nops = 1, .uops = { { _CALL_BUILTIN_CLASS 3, 0 } }}, + [CALL_BUILTIN_FAST] = { .nops = 1, .uops = { { _CALL_BUILTIN_FAST 3, 0 } }}, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { .nops = 1, .uops = { { _CALL_BUILTIN_FAST_WITH_KEYWORDS 3, 0 } }}, + [CALL_BUILTIN_O] = { .nops = 1, .uops = { { _CALL_BUILTIN_O 3, 0 } }}, + [CALL_FUNCTION_EX] = { .nops = 0, .uops = { }}, + [CALL_INTRINSIC_1] = { .nops = 1, .uops = { { _CALL_INTRINSIC_1 0, 0 } }}, + [CALL_INTRINSIC_2] = { .nops = 1, .uops = { { _CALL_INTRINSIC_2 0, 0 } }}, + [CALL_ISINSTANCE] = { .nops = 1, .uops = { { _CALL_ISINSTANCE 3, 0 } }}, + [CALL_KW] = { .nops = 0, .uops = { }}, + [CALL_LEN] = { .nops = 1, .uops = { { _CALL_LEN 3, 0 } }}, + [CALL_LIST_APPEND] = { .nops = 1, .uops = { { _CALL_LIST_APPEND 3, 0 } }}, + [CALL_METHOD_DESCRIPTOR_FAST] = { .nops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST 3, 0 } }}, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 3, 0 } }}, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_NOARGS 3, 0 } }}, + [CALL_METHOD_DESCRIPTOR_O] = { .nops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_O 3, 0 } }}, + [CALL_PY_EXACT_ARGS] = { .nops = 7, .uops = { { unused/1 1, 0 }, { _CHECK_PEP_523 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS 2, 1 }, { _CHECK_STACK_SPACE 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS 0, 0 }, { _SAVE_RETURN_OFFSET 7, 3 }, { _PUSH_FRAME 0, 0 } }}, + [CALL_PY_WITH_DEFAULTS] = { .nops = 0, .uops = { }}, + [CALL_STR_1] = { .nops = 1, .uops = { { _CALL_STR_1 3, 0 } }}, + [CALL_TUPLE_1] = { .nops = 1, .uops = { { _CALL_TUPLE_1 3, 0 } }}, + [CALL_TYPE_1] = { .nops = 1, .uops = { { _CALL_TYPE_1 3, 0 } }}, + [CHECK_EG_MATCH] = { .nops = 1, .uops = { { _CHECK_EG_MATCH 0, 0 } }}, + [CHECK_EXC_MATCH] = { .nops = 1, .uops = { { _CHECK_EXC_MATCH 0, 0 } }}, + [CLEANUP_THROW] = { .nops = 0, .uops = { }}, + [COMPARE_OP] = { .nops = 0, .uops = { }}, + [COMPARE_OP_FLOAT] = { .nops = 1, .uops = { { _COMPARE_OP_FLOAT 1, 0 } }}, + [COMPARE_OP_INT] = { .nops = 1, .uops = { { _COMPARE_OP_INT 1, 0 } }}, + [COMPARE_OP_STR] = { .nops = 1, .uops = { { _COMPARE_OP_STR 1, 0 } }}, + [CONTAINS_OP] = { .nops = 1, .uops = { { _CONTAINS_OP 0, 0 } }}, + [CONVERT_VALUE] = { .nops = 1, .uops = { { _CONVERT_VALUE 0, 0 } }}, + [COPY] = { .nops = 1, .uops = { { _COPY 0, 0 } }}, + [COPY_FREE_VARS] = { .nops = 1, .uops = { { _COPY_FREE_VARS 0, 0 } }}, + [DELETE_ATTR] = { .nops = 1, .uops = { { _DELETE_ATTR 0, 0 } }}, + [DELETE_DEREF] = { .nops = 1, .uops = { { _DELETE_DEREF 0, 0 } }}, + [DELETE_FAST] = { .nops = 1, .uops = { { _DELETE_FAST 0, 0 } }}, + [DELETE_GLOBAL] = { .nops = 1, .uops = { { _DELETE_GLOBAL 0, 0 } }}, + [DELETE_NAME] = { .nops = 1, .uops = { { _DELETE_NAME 0, 0 } }}, + [DELETE_SUBSCR] = { .nops = 1, .uops = { { _DELETE_SUBSCR 0, 0 } }}, + [DICT_MERGE] = { .nops = 1, .uops = { { _DICT_MERGE 0, 0 } }}, + [DICT_UPDATE] = { .nops = 1, .uops = { { _DICT_UPDATE 0, 0 } }}, + [END_ASYNC_FOR] = { .nops = 0, .uops = { }}, + [END_FOR] = { .nops = 2, .uops = { { _POP_TOP 0, 0 }, { _POP_TOP 0, 0 } }}, + [END_SEND] = { .nops = 1, .uops = { { _END_SEND 0, 0 } }}, + [ENTER_EXECUTOR] = { .nops = 1, .uops = { { _ENTER_EXECUTOR 0, 0 } }}, + [EXIT_INIT_CHECK] = { .nops = 1, .uops = { { _EXIT_INIT_CHECK 0, 0 } }}, + [EXTENDED_ARG] = { .nops = 1, .uops = { { _EXTENDED_ARG 0, 0 } }}, + [FORMAT_SIMPLE] = { .nops = 1, .uops = { { _FORMAT_SIMPLE 0, 0 } }}, + [FORMAT_WITH_SPEC] = { .nops = 1, .uops = { { _FORMAT_WITH_SPEC 0, 0 } }}, + [FOR_ITER] = { .nops = 0, .uops = { }}, + [FOR_ITER_GEN] = { .nops = 0, .uops = { }}, + [FOR_ITER_LIST] = { .nops = 0, .uops = { }}, + [FOR_ITER_RANGE] = { .nops = 0, .uops = { }}, + [FOR_ITER_TUPLE] = { .nops = 0, .uops = { }}, + [GET_AITER] = { .nops = 1, .uops = { { _GET_AITER 0, 0 } }}, + [GET_ANEXT] = { .nops = 1, .uops = { { _GET_ANEXT 0, 0 } }}, + [GET_AWAITABLE] = { .nops = 1, .uops = { { _GET_AWAITABLE 0, 0 } }}, + [GET_ITER] = { .nops = 1, .uops = { { _GET_ITER 0, 0 } }}, + [GET_LEN] = { .nops = 1, .uops = { { _GET_LEN 0, 0 } }}, + [GET_YIELD_FROM_ITER] = { .nops = 1, .uops = { { _GET_YIELD_FROM_ITER 0, 0 } }}, + [IMPORT_FROM] = { .nops = 1, .uops = { { _IMPORT_FROM 0, 0 } }}, + [IMPORT_NAME] = { .nops = 1, .uops = { { _IMPORT_NAME 0, 0 } }}, + [INSTRUMENTED_CALL] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_CALL_FUNCTION_EX] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_CALL_KW] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_END_FOR] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_END_SEND] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_FOR_ITER] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_INSTRUCTION] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_JUMP_BACKWARD] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_JUMP_FORWARD] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_LOAD_SUPER_ATTR] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_POP_JUMP_IF_NONE] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_RESUME] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_RETURN_CONST] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_RETURN_VALUE] = { .nops = 0, .uops = { }}, + [INSTRUMENTED_YIELD_VALUE] = { .nops = 0, .uops = { }}, + [INTERPRETER_EXIT] = { .nops = 1, .uops = { { _INTERPRETER_EXIT 0, 0 } }}, + [IS_OP] = { .nops = 1, .uops = { { _IS_OP 0, 0 } }}, + [JUMP_BACKWARD] = { .nops = 0, .uops = { }}, + [JUMP_BACKWARD_NO_INTERRUPT] = { .nops = 1, .uops = { { _JUMP_BACKWARD_NO_INTERRUPT 0, 0 } }}, + [JUMP_FORWARD] = { .nops = 1, .uops = { { _JUMP_FORWARD 0, 0 } }}, + [LIST_APPEND] = { .nops = 1, .uops = { { _LIST_APPEND 0, 0 } }}, + [LIST_EXTEND] = { .nops = 1, .uops = { { _LIST_EXTEND 0, 0 } }}, + [LOAD_ASSERTION_ERROR] = { .nops = 1, .uops = { { _LOAD_ASSERTION_ERROR 0, 0 } }}, + [LOAD_ATTR] = { .nops = 0, .uops = { }}, + [LOAD_ATTR_CLASS] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _CHECK_ATTR_CLASS 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_CLASS 4, 5 } }}, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { .nops = 0, .uops = { }}, + [LOAD_ATTR_INSTANCE_VALUE] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE 1, 3 }, { unused/5 5, 4 } }}, + [LOAD_ATTR_METHOD_LAZY_DICT] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT 0, 0 }, { unused/2 2, 3 }, { _LOAD_ATTR_METHOD_LAZY_DICT 4, 5 } }}, + [LOAD_ATTR_METHOD_NO_DICT] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_METHOD_NO_DICT 4, 5 } }}, + [LOAD_ATTR_METHOD_WITH_VALUES] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 0, 0 }, { _GUARD_KEYS_VERSION 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES 4, 5 } }}, + [LOAD_ATTR_MODULE] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _CHECK_ATTR_MODULE 2, 1 }, { _LOAD_ATTR_MODULE 1, 3 }, { unused/5 5, 4 } }}, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 4, 5 } }}, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 0, 0 }, { _GUARD_KEYS_VERSION 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 4, 5 } }}, + [LOAD_ATTR_PROPERTY] = { .nops = 0, .uops = { }}, + [LOAD_ATTR_SLOT] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _LOAD_ATTR_SLOT 1, 3 }, { unused/5 5, 4 } }}, + [LOAD_ATTR_WITH_HINT] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_ATTR_WITH_HINT 0, 0 }, { _LOAD_ATTR_WITH_HINT 1, 3 }, { unused/5 5, 4 } }}, + [LOAD_BUILD_CLASS] = { .nops = 1, .uops = { { _LOAD_BUILD_CLASS 0, 0 } }}, + [LOAD_CONST] = { .nops = 1, .uops = { { _LOAD_CONST 0, 0 } }}, + [LOAD_DEREF] = { .nops = 1, .uops = { { _LOAD_DEREF 0, 0 } }}, + [LOAD_FAST] = { .nops = 1, .uops = { { _LOAD_FAST 0, 0 } }}, + [LOAD_FAST_AND_CLEAR] = { .nops = 1, .uops = { { _LOAD_FAST_AND_CLEAR 0, 0 } }}, + [LOAD_FAST_CHECK] = { .nops = 1, .uops = { { _LOAD_FAST_CHECK 0, 0 } }}, + [LOAD_FAST_LOAD_FAST] = { .nops = 2, .uops = { { _LOAD_FAST 5, 0 }, { _LOAD_FAST 6, 0 } }}, + [LOAD_FROM_DICT_OR_DEREF] = { .nops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF 0, 0 } }}, + [LOAD_FROM_DICT_OR_GLOBALS] = { .nops = 1, .uops = { { _LOAD_FROM_DICT_OR_GLOBALS 0, 0 } }}, + [LOAD_GLOBAL] = { .nops = 0, .uops = { }}, + [LOAD_GLOBAL_BUILTIN] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_GLOBALS_VERSION 1, 1 }, { _GUARD_BUILTINS_VERSION 1, 2 }, { _LOAD_GLOBAL_BUILTINS 1, 3 } }}, + [LOAD_GLOBAL_MODULE] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_GLOBALS_VERSION 1, 1 }, { unused/1 1, 2 }, { _LOAD_GLOBAL_MODULE 1, 3 } }}, + [LOAD_LOCALS] = { .nops = 1, .uops = { { _LOAD_LOCALS 0, 0 } }}, + [LOAD_NAME] = { .nops = 1, .uops = { { _LOAD_NAME 0, 0 } }}, + [LOAD_SUPER_ATTR] = { .nops = 0, .uops = { }}, + [LOAD_SUPER_ATTR_ATTR] = { .nops = 1, .uops = { { _LOAD_SUPER_ATTR_ATTR 1, 0 } }}, + [LOAD_SUPER_ATTR_METHOD] = { .nops = 1, .uops = { { _LOAD_SUPER_ATTR_METHOD 1, 0 } }}, + [MAKE_CELL] = { .nops = 1, .uops = { { _MAKE_CELL 0, 0 } }}, + [MAKE_FUNCTION] = { .nops = 1, .uops = { { _MAKE_FUNCTION 0, 0 } }}, + [MAP_ADD] = { .nops = 1, .uops = { { _MAP_ADD 0, 0 } }}, + [MATCH_CLASS] = { .nops = 1, .uops = { { _MATCH_CLASS 0, 0 } }}, + [MATCH_KEYS] = { .nops = 1, .uops = { { _MATCH_KEYS 0, 0 } }}, + [MATCH_MAPPING] = { .nops = 1, .uops = { { _MATCH_MAPPING 0, 0 } }}, + [MATCH_SEQUENCE] = { .nops = 1, .uops = { { _MATCH_SEQUENCE 0, 0 } }}, + [NOP] = { .nops = 1, .uops = { { _NOP 0, 0 } }}, + [POP_EXCEPT] = { .nops = 1, .uops = { { _POP_EXCEPT 0, 0 } }}, + [POP_JUMP_IF_FALSE] = { .nops = 0, .uops = { }}, + [POP_JUMP_IF_NONE] = { .nops = 0, .uops = { }}, + [POP_JUMP_IF_NOT_NONE] = { .nops = 0, .uops = { }}, + [POP_JUMP_IF_TRUE] = { .nops = 0, .uops = { }}, + [POP_TOP] = { .nops = 1, .uops = { { _POP_TOP 0, 0 } }}, + [PUSH_EXC_INFO] = { .nops = 1, .uops = { { _PUSH_EXC_INFO 0, 0 } }}, + [PUSH_NULL] = { .nops = 1, .uops = { { _PUSH_NULL 0, 0 } }}, + [RAISE_VARARGS] = { .nops = 0, .uops = { }}, + [RERAISE] = { .nops = 0, .uops = { }}, + [RESERVED] = { .nops = 1, .uops = { { _RESERVED 0, 0 } }}, + [RESUME] = { .nops = 0, .uops = { }}, + [RESUME_CHECK] = { .nops = 1, .uops = { { _RESUME_CHECK 0, 0 } }}, + [RETURN_CONST] = { .nops = 2, .uops = { { _LOAD_CONST 0, 0 }, { _POP_FRAME 0, 0 } }}, + [RETURN_GENERATOR] = { .nops = 1, .uops = { { _RETURN_GENERATOR 0, 0 } }}, + [RETURN_VALUE] = { .nops = 1, .uops = { { _POP_FRAME 0, 0 } }}, + [SEND] = { .nops = 0, .uops = { }}, + [SEND_GEN] = { .nops = 0, .uops = { }}, + [SETUP_ANNOTATIONS] = { .nops = 1, .uops = { { _SETUP_ANNOTATIONS 0, 0 } }}, + [SET_ADD] = { .nops = 1, .uops = { { _SET_ADD 0, 0 } }}, + [SET_FUNCTION_ATTRIBUTE] = { .nops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE 0, 0 } }}, + [SET_UPDATE] = { .nops = 1, .uops = { { _SET_UPDATE 0, 0 } }}, + [STORE_ATTR] = { .nops = 0, .uops = { }}, + [STORE_ATTR_INSTANCE_VALUE] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE 1, 3 } }}, + [STORE_ATTR_SLOT] = { .nops = 3, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _STORE_ATTR_SLOT 1, 3 } }}, + [STORE_ATTR_WITH_HINT] = { .nops = 0, .uops = { }}, + [STORE_DEREF] = { .nops = 1, .uops = { { _STORE_DEREF 0, 0 } }}, + [STORE_FAST] = { .nops = 1, .uops = { { _STORE_FAST 0, 0 } }}, + [STORE_FAST_LOAD_FAST] = { .nops = 2, .uops = { { _STORE_FAST 5, 0 }, { _LOAD_FAST 6, 0 } }}, + [STORE_FAST_STORE_FAST] = { .nops = 2, .uops = { { _STORE_FAST 5, 0 }, { _STORE_FAST 6, 0 } }}, + [STORE_GLOBAL] = { .nops = 1, .uops = { { _STORE_GLOBAL 0, 0 } }}, + [STORE_NAME] = { .nops = 1, .uops = { { _STORE_NAME 0, 0 } }}, + [STORE_SLICE] = { .nops = 1, .uops = { { _STORE_SLICE 0, 0 } }}, + [STORE_SUBSCR] = { .nops = 0, .uops = { }}, + [STORE_SUBSCR_DICT] = { .nops = 1, .uops = { { _STORE_SUBSCR_DICT 1, 0 } }}, + [STORE_SUBSCR_LIST_INT] = { .nops = 1, .uops = { { _STORE_SUBSCR_LIST_INT 1, 0 } }}, + [SWAP] = { .nops = 1, .uops = { { _SWAP 0, 0 } }}, + [TO_BOOL] = { .nops = 0, .uops = { }}, + [TO_BOOL_ALWAYS_TRUE] = { .nops = 1, .uops = { { _TO_BOOL_ALWAYS_TRUE 3, 0 } }}, + [TO_BOOL_BOOL] = { .nops = 1, .uops = { { _TO_BOOL_BOOL 3, 0 } }}, + [TO_BOOL_INT] = { .nops = 1, .uops = { { _TO_BOOL_INT 3, 0 } }}, + [TO_BOOL_LIST] = { .nops = 1, .uops = { { _TO_BOOL_LIST 3, 0 } }}, + [TO_BOOL_NONE] = { .nops = 1, .uops = { { _TO_BOOL_NONE 3, 0 } }}, + [TO_BOOL_STR] = { .nops = 1, .uops = { { _TO_BOOL_STR 3, 0 } }}, + [UNARY_INVERT] = { .nops = 1, .uops = { { _UNARY_INVERT 0, 0 } }}, + [UNARY_NEGATIVE] = { .nops = 1, .uops = { { _UNARY_NEGATIVE 0, 0 } }}, + [UNARY_NOT] = { .nops = 1, .uops = { { _UNARY_NOT 0, 0 } }}, + [UNPACK_EX] = { .nops = 1, .uops = { { _UNPACK_EX 0, 0 } }}, + [UNPACK_SEQUENCE] = { .nops = 0, .uops = { }}, + [UNPACK_SEQUENCE_LIST] = { .nops = 1, .uops = { { _UNPACK_SEQUENCE_LIST 1, 0 } }}, + [UNPACK_SEQUENCE_TUPLE] = { .nops = 1, .uops = { { _UNPACK_SEQUENCE_TUPLE 1, 0 } }}, + [UNPACK_SEQUENCE_TWO_TUPLE] = { .nops = 1, .uops = { { _UNPACK_SEQUENCE_TWO_TUPLE 1, 0 } }}, + [WITH_EXCEPT_START] = { .nops = 1, .uops = { { _WITH_EXCEPT_START 0, 0 } }}, + [YIELD_VALUE] = { .nops = 1, .uops = { { _YIELD_VALUE 0, 0 } }}, +}; +#endif // NEED_OPCODE_METADATA + const char *_PyOpcode_OpName[268] = { [BEFORE_ASYNC_WITH] = "BEFORE_ASYNC_WITH", [BEFORE_WITH] = "BEFORE_WITH", @@ -846,7 +1067,6 @@ is_pseudo_target(int pseudo, int target) { return false; } -#endif // Py_BUILD_CORE #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 0b8629669f73d0..acf03621bb0ca6 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -534,15 +534,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { }; #endif // NEED_OPCODE_METADATA -extern const struct opcode_macro_expansion -_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE]; - -#ifdef NEED_OPCODE_METADATA -const struct opcode_macro_expansion -_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE] = { -}; -#endif // NEED_OPCODE_METADATA - #ifdef __cplusplus } diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index e646f2c78604ae..2edb00ba00b3c2 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -74,7 +74,6 @@ def name(self) -> str: def properties(self) -> Properties: return SKIP_PROPERTIES - @dataclass class StackItem: name: str @@ -151,6 +150,12 @@ def is_viable(self) -> bool: return False return True + def is_super(self) -> bool: + for tkn in self.body: + if tkn.kind == "IDENTIFIER" and tkn.text == "oparg1": + return True + return False + Part = Uop | Skip @@ -180,6 +185,15 @@ def dump(self, indent: str) -> None: def size(self) -> int: return 1 + sum(part.size for part in self.parts) + def is_super(self) -> bool: + if len(self.parts) != 1: + return False + uop = self.parts[0] + if isinstance(uop, Uop): + return uop.is_super() + else: + return False + @dataclass class PseudoInstruction: diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 8ff961376ede94..78813510935852 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -12,6 +12,7 @@ Instruction, analyze_files, Skip, + Uop, ) from generators_common import ( DEFAULT_INPUT, @@ -23,19 +24,31 @@ from cwriter import CWriter from typing import TextIO +# Constants used instead of size for macro expansions. +# Note: 1, 2, 4 must match actual cache entry sizes. +OPARG_SIZES = { + "OPARG_FULL": 0, + "OPARG_CACHE_1": 1, + "OPARG_CACHE_2": 2, + "OPARG_CACHE_4": 4, + "OPARG_TOP": 5, + "OPARG_BOTTOM": 6, + "OPARG_SAVE_RETURN_OFFSET": 7, +} + DEFAULT_OUTPUT = ROOT / "Include/internal/pycore_uop_metadata.h" FLAGS = [ "ARG", "CONST", - "ERROR", "NAME", - "FREE", "JUMP", + "LOCAL", + "ERROR", + "FREE", "DEOPT", "ESCAPES", - "LOCAL", ] def generate_flag_macros(out: CWriter) -> None: @@ -131,6 +144,58 @@ def generate_metadata_table( out.emit(f"[{inst.name}] = {{ true, {get_format(inst)}, {cflags(inst.properties)} }},\n") out.emit("};\n\n") +def generate_expansion_table( + analysis: Analysis, out: CWriter +) -> None: + expansions_table: dict[str, list[tuple[str, int, int]]] = {} + for inst in sorted(analysis.instructions.values(), key=lambda t:t.name): + offset: int = 0 # Cache effect offset + expansions: list[tuple[str, int, int]] = [] # [(name, size, offset), ...] + if inst.is_super(): + pieces = inst.name.split("_") + assert len(pieces) == 4, f"{name} doesn't look like a super-instr" + name1 = "_".join(pieces[:2]) + name2 = "_".join(pieces[2:]) + assert name1 in analysis.instructions, f"{name1} doesn't match any instr" + assert name2 in analysis.instructions, f"{name2} doesn't match any instr" + instr1 = analysis.instructions[name1] + instr2 = analysis.instructions[name2] + assert len(instr1.parts) == 1, f"{name1} is not a good superinstruction part" + assert len(instr2.parts) == 1, f"{name2} is not a good superinstruction part" + expansions.append((instr1.parts[0].name, OPARG_SIZES["OPARG_TOP"], 0)) + expansions.append((instr2.parts[0].name, OPARG_SIZES["OPARG_BOTTOM"], 0)) + elif is_viable_expansion(inst): + for part in inst.parts: + size = part.size + if part.name == "_SAVE_RETURN_OFFSET": + size = OPARG_SIZES["OPARG_SAVE_RETURN_OFFSET"] + expansions.append((part.name, size, offset if size else 0)) + offset += part.size + expansions_table[inst.name] = expansions + max_uops = max (len(ex) for ex in expansions_table.values()) + out.emit(f"#define MAX_UOP_PER_EXPANSION {max_uops}\n") + out.emit("struct opcode_macro_expansion {\n") + out.emit("int nuops;") + out.emit("struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION];\n") + out.emit("};\n") + out.emit("extern const struct opcode_macro_expansion\n") + out.emit("_PyOpcode_macro_expansion[256];\n\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") + out.emit("const struct opcode_macro_expansion\n") + out.emit("_PyOpcode_macro_expansion[256] = {\n") + for inst_name, expansions in expansions_table.items(): + uops = [f"{{ {name} {size}, {offset} }}" for (name, size, offset) in expansions] + out.emit(f"[{inst_name}] = {{ .nops = {len(expansions)}, .uops = {{ {", ".join(uops)} }}}},\n") + out.emit("};\n") + out.emit("#endif // NEED_OPCODE_METADATA\n\n") + +def is_viable_expansion(inst: Instruction) -> bool: + "An instruction can be expanded if all its parts are viable for tier 2" + for part in inst.parts: + if isinstance(part, Uop) and not part.is_viable(): + return False + return True + def generate_psuedo_targets( analysis: Analysis, out: CWriter @@ -170,6 +235,7 @@ def generate_opcode_metadata( with out.header_guard("Py_CORE_OPCODE_METADATA_H"): out.emit("#ifndef Py_BUILD_CORE\n") out.emit('# error "this header requires Py_BUILD_CORE define"\n') + out.emit("#endif\n") out.emit("#include // bool\n") out.emit('#include "opcode_ids.h"\n') generate_is_pseudo(analysis, out) @@ -177,14 +243,14 @@ def generate_opcode_metadata( generate_instruction_formats(analysis, out) out.emit("#define IS_VALID_OPCODE(OP) \\\n") out.emit(" (((OP) >= 0) && ((OP) < 256) && \\\n") - out.emit(" (_PyOpcode_opcode_metadata[(OP)].valid_entry))\n\n") + out.emit(" (_PyOpcode_opcode_metadata[(OP)].valid_entry))\n\n") generate_flag_macros(out) generate_deopt_table(analysis, out) generate_cache_table(analysis, out) generate_metadata_table(analysis, out) + generate_expansion_table(analysis, out) generate_name_table(analysis, out) generate_psuedo_targets(analysis, out) - out.emit("#endif // Py_BUILD_CORE\n") arg_parser = argparse.ArgumentParser( diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index a22fb6dd932503..39732d11f6828c 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -103,13 +103,6 @@ def tier2_replace_deopt( TIER2_REPLACEMENT_FUNCTIONS["DEOPT_IF"] = tier2_replace_deopt -def is_super(uop: Uop) -> bool: - for tkn in uop.body: - if tkn.kind == "IDENTIFIER" and tkn.text == "oparg1": - return True - return False - - def write_uop(uop: Uop, out: CWriter, stack: Stack) -> None: try: out.start_line() @@ -156,7 +149,7 @@ def generate_tier2( for name, uop in analysis.uops.items(): if uop.properties.tier_one_only: continue - if is_super(uop): + if uop.is_super(): continue if not uop.is_viable(): out.emit(f"/* {uop.name} is not a viable micro-op for tier 2 */\n\n") diff --git a/Tools/cases_generator/uop_metadata_generator.py b/Tools/cases_generator/uop_metadata_generator.py index 9daf58df7f00ed..fa14a0757547b8 100644 --- a/Tools/cases_generator/uop_metadata_generator.py +++ b/Tools/cases_generator/uop_metadata_generator.py @@ -11,6 +11,7 @@ Analysis, Instruction, analyze_files, + Uop, ) from generators_common import ( DEFAULT_INPUT, @@ -41,19 +42,6 @@ def generate_names_and_flags( out.emit(f'[{name}] = "{name}",\n') out.emit("};\n") out.emit("#endif // NEED_OPCODE_METADATA\n\n") - -def generate_expansion_table( - analysis: Analysis, out: CWriter -) -> None: - out.emit("extern const struct opcode_macro_expansion\n") - out.emit("_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE];\n\n") - out.emit("#ifdef NEED_OPCODE_METADATA\n") - out.emit("const struct opcode_macro_expansion\n") - out.emit("_PyOpcode_macro_expansion[OPCODE_MACRO_EXPANSION_SIZE] = {\n") - - - out.emit("};\n") - out.emit("#endif // NEED_OPCODE_METADATA\n\n") def generate_uop_metadata( filenames: list[str], analysis: Analysis, outfile: TextIO @@ -64,7 +52,6 @@ def generate_uop_metadata( out.emit('#include \n') out.emit('#include "pycore_uop_ids.h"\n') generate_names_and_flags(analysis, out) - generate_expansion_table(analysis, out) arg_parser = argparse.ArgumentParser( description="Generate the header file with uop metadata.", From d81585dc2d715f6358390ef73854a907ced52da1 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 02:23:56 +0000 Subject: [PATCH 04/51] Reorganise a bit to reduce output diff --- Include/internal/pycore_opcode_metadata.h | 1015 +++++++++-------- .../opcode_metadata_generator.py | 15 +- 2 files changed, 517 insertions(+), 513 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 7c9a0a53398071..23c222d7e4fab2 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -12,6 +12,7 @@ extern "C" { #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif + #include // bool #include "opcode_ids.h" @@ -31,7 +32,7 @@ extern "C" { ((OP) == POP_BLOCK) || \ 0) -#include "pycore_uops.h" +#include "pycore_uop_ids.h" enum InstructionFormat { INSTR_FMT_IB = 1, INSTR_FMT_IBC = 2, @@ -52,545 +53,236 @@ enum InstructionFormat { #define HAS_CONST_FLAG (2) #define HAS_NAME_FLAG (4) #define HAS_JUMP_FLAG (8) -#define HAS_LOCAL_FLAG (16) -#define HAS_ERROR_FLAG (32) -#define HAS_FREE_FLAG (64) +#define HAS_FREE_FLAG (16) +#define HAS_LOCAL_FLAG (32) +#define HAS_EVAL_BREAK_FLAG (64) #define HAS_DEOPT_FLAG (128) -#define HAS_ESCAPES_FLAG (256) +#define HAS_ERROR_FLAG (256) +#define HAS_ESCAPES_FLAG (512) #define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) #define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) #define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) #define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) -#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) -#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) #define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) +#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) +#define OPCODE_HAS_EVAL_BREAK(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_EVAL_BREAK_FLAG)) #define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) +#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) #define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) -extern const uint8_t _PyOpcode_Deopt[256]; -#ifdef NEED_OPCODE_METADATA -const uint8_t _PyOpcode_Deopt[256] = { - [NOP] = NOP, - [RESUME] = RESUME, - [RESUME_CHECK] = RESUME, - [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, - [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, - [LOAD_FAST] = LOAD_FAST, - [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, - [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, - [LOAD_CONST] = LOAD_CONST, - [STORE_FAST] = STORE_FAST, - [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, - [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, - [POP_TOP] = POP_TOP, - [PUSH_NULL] = PUSH_NULL, - [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, - [END_SEND] = END_SEND, - [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, - [UNARY_NEGATIVE] = UNARY_NEGATIVE, - [UNARY_NOT] = UNARY_NOT, - [TO_BOOL_BOOL] = TO_BOOL, - [TO_BOOL_INT] = TO_BOOL, - [TO_BOOL_LIST] = TO_BOOL, - [TO_BOOL_NONE] = TO_BOOL, - [TO_BOOL_STR] = TO_BOOL, - [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, - [UNARY_INVERT] = UNARY_INVERT, - [BINARY_SLICE] = BINARY_SLICE, - [STORE_SLICE] = STORE_SLICE, - [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, - [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, - [LIST_APPEND] = LIST_APPEND, - [SET_ADD] = SET_ADD, - [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, - [STORE_SUBSCR_DICT] = STORE_SUBSCR, - [DELETE_SUBSCR] = DELETE_SUBSCR, - [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, - [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, - [RAISE_VARARGS] = RAISE_VARARGS, - [INTERPRETER_EXIT] = INTERPRETER_EXIT, - [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, - [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST, - [GET_AITER] = GET_AITER, - [GET_ANEXT] = GET_ANEXT, - [GET_AWAITABLE] = GET_AWAITABLE, - [SEND_GEN] = SEND, - [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, - [YIELD_VALUE] = YIELD_VALUE, - [POP_EXCEPT] = POP_EXCEPT, - [RERAISE] = RERAISE, - [END_ASYNC_FOR] = END_ASYNC_FOR, - [CLEANUP_THROW] = CLEANUP_THROW, - [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, - [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, - [STORE_NAME] = STORE_NAME, - [DELETE_NAME] = DELETE_NAME, - [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, - [UNPACK_EX] = UNPACK_EX, - [DELETE_ATTR] = DELETE_ATTR, - [STORE_GLOBAL] = STORE_GLOBAL, - [DELETE_GLOBAL] = DELETE_GLOBAL, - [LOAD_LOCALS] = LOAD_LOCALS, - [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, - [LOAD_NAME] = LOAD_NAME, - [DELETE_FAST] = DELETE_FAST, - [MAKE_CELL] = MAKE_CELL, - [DELETE_DEREF] = DELETE_DEREF, - [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, - [LOAD_DEREF] = LOAD_DEREF, - [STORE_DEREF] = STORE_DEREF, - [COPY_FREE_VARS] = COPY_FREE_VARS, - [BUILD_STRING] = BUILD_STRING, - [BUILD_TUPLE] = BUILD_TUPLE, - [BUILD_LIST] = BUILD_LIST, - [LIST_EXTEND] = LIST_EXTEND, - [SET_UPDATE] = SET_UPDATE, - [BUILD_SET] = BUILD_SET, - [BUILD_MAP] = BUILD_MAP, - [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, - [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, - [DICT_UPDATE] = DICT_UPDATE, - [DICT_MERGE] = DICT_MERGE, - [MAP_ADD] = MAP_ADD, - [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, - [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, - [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, - [LOAD_ATTR_PROPERTY] = LOAD_ATTR, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, - [STORE_ATTR_WITH_HINT] = STORE_ATTR, - [COMPARE_OP_FLOAT] = COMPARE_OP, - [COMPARE_OP_INT] = COMPARE_OP, - [COMPARE_OP_STR] = COMPARE_OP, - [IS_OP] = IS_OP, - [CONTAINS_OP] = CONTAINS_OP, - [CHECK_EG_MATCH] = CHECK_EG_MATCH, - [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, - [IMPORT_NAME] = IMPORT_NAME, - [IMPORT_FROM] = IMPORT_FROM, - [JUMP_FORWARD] = JUMP_FORWARD, - [JUMP_BACKWARD] = JUMP_BACKWARD, - [ENTER_EXECUTOR] = ENTER_EXECUTOR, - [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, - [GET_LEN] = GET_LEN, - [MATCH_CLASS] = MATCH_CLASS, - [MATCH_MAPPING] = MATCH_MAPPING, - [MATCH_SEQUENCE] = MATCH_SEQUENCE, - [MATCH_KEYS] = MATCH_KEYS, - [GET_ITER] = GET_ITER, - [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, - [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, - [FOR_ITER_GEN] = FOR_ITER, - [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, - [BEFORE_WITH] = BEFORE_WITH, - [WITH_EXCEPT_START] = WITH_EXCEPT_START, - [PUSH_EXC_INFO] = PUSH_EXC_INFO, - [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, - [CALL_PY_WITH_DEFAULTS] = CALL, - [CALL_TYPE_1] = CALL, - [CALL_STR_1] = CALL, - [CALL_TUPLE_1] = CALL, - [CALL_ALLOC_AND_ENTER_INIT] = CALL, - [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, - [CALL_BUILTIN_CLASS] = CALL, - [CALL_BUILTIN_O] = CALL, - [CALL_BUILTIN_FAST] = CALL, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, - [CALL_LEN] = CALL, - [CALL_ISINSTANCE] = CALL, - [CALL_LIST_APPEND] = CALL, - [CALL_METHOD_DESCRIPTOR_O] = CALL, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, - [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL, - [CALL_METHOD_DESCRIPTOR_FAST] = CALL, - [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, - [CALL_KW] = CALL_KW, - [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, - [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, - [MAKE_FUNCTION] = MAKE_FUNCTION, - [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, - [RETURN_GENERATOR] = RETURN_GENERATOR, - [BUILD_SLICE] = BUILD_SLICE, - [CONVERT_VALUE] = CONVERT_VALUE, - [FORMAT_SIMPLE] = FORMAT_SIMPLE, - [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC, - [COPY] = COPY, - [SWAP] = SWAP, - [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, - [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, - [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, - [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, - [EXTENDED_ARG] = EXTENDED_ARG, - [CACHE] = CACHE, - [RESERVED] = RESERVED, - [END_FOR] = END_FOR, - [TO_BOOL] = TO_BOOL, - [BINARY_OP_MULTIPLY_INT] = BINARY_OP, - [BINARY_OP_ADD_INT] = BINARY_OP, - [BINARY_OP_SUBTRACT_INT] = BINARY_OP, - [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, - [BINARY_OP_ADD_FLOAT] = BINARY_OP, - [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, - [BINARY_OP_ADD_UNICODE] = BINARY_OP, - [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, - [BINARY_SUBSCR] = BINARY_SUBSCR, - [STORE_SUBSCR] = STORE_SUBSCR, - [RETURN_VALUE] = RETURN_VALUE, - [RETURN_CONST] = RETURN_CONST, - [SEND] = SEND, - [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, - [STORE_ATTR] = STORE_ATTR, - [LOAD_GLOBAL] = LOAD_GLOBAL, - [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, - [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, - [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, - [LOAD_ATTR] = LOAD_ATTR, - [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, - [LOAD_ATTR_MODULE] = LOAD_ATTR, - [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, - [LOAD_ATTR_SLOT] = LOAD_ATTR, - [LOAD_ATTR_CLASS] = LOAD_ATTR, - [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, - [STORE_ATTR_SLOT] = STORE_ATTR, - [COMPARE_OP] = COMPARE_OP, - [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, - [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, - [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, - [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, - [FOR_ITER] = FOR_ITER, - [FOR_ITER_LIST] = FOR_ITER, - [FOR_ITER_TUPLE] = FOR_ITER, - [FOR_ITER_RANGE] = FOR_ITER, - [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, - [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, - [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, - [CALL] = CALL, - [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, - [CALL_PY_EXACT_ARGS] = CALL, - [BINARY_OP] = BINARY_OP, -}; - -#endif // NEED_OPCODE_METADATA -const uint8_t _PyOpcode_Caches[256] = { - [TO_BOOL_BOOL] = 3, - [TO_BOOL_INT] = 3, - [TO_BOOL_LIST] = 3, - [TO_BOOL_NONE] = 3, - [TO_BOOL_STR] = 3, - [TO_BOOL_ALWAYS_TRUE] = 3, - [BINARY_SUBSCR_LIST_INT] = 1, - [BINARY_SUBSCR_STR_INT] = 1, - [BINARY_SUBSCR_TUPLE_INT] = 1, - [BINARY_SUBSCR_DICT] = 1, - [BINARY_SUBSCR_GETITEM] = 1, - [STORE_SUBSCR_LIST_INT] = 1, - [STORE_SUBSCR_DICT] = 1, - [SEND_GEN] = 1, - [UNPACK_SEQUENCE_TWO_TUPLE] = 1, - [UNPACK_SEQUENCE_TUPLE] = 1, - [UNPACK_SEQUENCE_LIST] = 1, - [INSTRUMENTED_LOAD_SUPER_ATTR] = 1, - [LOAD_SUPER_ATTR_ATTR] = 1, - [LOAD_SUPER_ATTR_METHOD] = 1, - [LOAD_ATTR_PROPERTY] = 9, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = 9, - [STORE_ATTR_WITH_HINT] = 4, - [COMPARE_OP_FLOAT] = 1, - [COMPARE_OP_INT] = 1, - [COMPARE_OP_STR] = 1, - [JUMP_BACKWARD] = 1, - [INSTRUMENTED_FOR_ITER] = 1, - [FOR_ITER_GEN] = 1, - [INSTRUMENTED_CALL] = 3, - [CALL_PY_WITH_DEFAULTS] = 3, - [CALL_TYPE_1] = 3, - [CALL_STR_1] = 3, - [CALL_TUPLE_1] = 3, - [CALL_ALLOC_AND_ENTER_INIT] = 3, - [CALL_BUILTIN_CLASS] = 3, - [CALL_BUILTIN_O] = 3, - [CALL_BUILTIN_FAST] = 3, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = 3, - [CALL_LEN] = 3, - [CALL_ISINSTANCE] = 3, - [CALL_LIST_APPEND] = 3, - [CALL_METHOD_DESCRIPTOR_O] = 3, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = 3, - [CALL_METHOD_DESCRIPTOR_NOARGS] = 3, - [CALL_METHOD_DESCRIPTOR_FAST] = 3, - [INSTRUMENTED_JUMP_BACKWARD] = 1, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = 1, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = 1, - [INSTRUMENTED_POP_JUMP_IF_NONE] = 1, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = 1, - [TO_BOOL] = 3, - [BINARY_OP_MULTIPLY_INT] = 1, - [BINARY_OP_ADD_INT] = 1, - [BINARY_OP_SUBTRACT_INT] = 1, - [BINARY_OP_MULTIPLY_FLOAT] = 1, - [BINARY_OP_ADD_FLOAT] = 1, - [BINARY_OP_SUBTRACT_FLOAT] = 1, - [BINARY_OP_ADD_UNICODE] = 1, - [BINARY_OP_INPLACE_ADD_UNICODE] = 1, - [BINARY_SUBSCR] = 1, - [STORE_SUBSCR] = 1, - [SEND] = 1, - [UNPACK_SEQUENCE] = 1, - [STORE_ATTR] = 4, - [LOAD_GLOBAL] = 4, - [LOAD_GLOBAL_MODULE] = 4, - [LOAD_GLOBAL_BUILTIN] = 4, - [LOAD_SUPER_ATTR] = 1, - [LOAD_ATTR] = 9, - [LOAD_ATTR_INSTANCE_VALUE] = 9, - [LOAD_ATTR_MODULE] = 9, - [LOAD_ATTR_WITH_HINT] = 9, - [LOAD_ATTR_SLOT] = 9, - [LOAD_ATTR_CLASS] = 9, - [STORE_ATTR_INSTANCE_VALUE] = 4, - [STORE_ATTR_SLOT] = 4, - [COMPARE_OP] = 1, - [POP_JUMP_IF_TRUE] = 1, - [POP_JUMP_IF_FALSE] = 1, - [POP_JUMP_IF_NONE] = 1, - [POP_JUMP_IF_NOT_NONE] = 1, - [FOR_ITER] = 1, - [FOR_ITER_LIST] = 1, - [FOR_ITER_TUPLE] = 1, - [FOR_ITER_RANGE] = 1, - [LOAD_ATTR_METHOD_WITH_VALUES] = 9, - [LOAD_ATTR_METHOD_NO_DICT] = 9, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = 9, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = 9, - [LOAD_ATTR_METHOD_LAZY_DICT] = 9, - [CALL] = 3, - [CALL_BOUND_METHOD_EXACT_ARGS] = 3, - [CALL_PY_EXACT_ARGS] = 3, - [BINARY_OP] = 1, -}; - -struct opcode_metadata { - uint8_t valid_entry; - uint8_t instr_format; - uint16_t flags; +struct opcode_metadata { + uint8_t valid_entry; + uint8_t instr_format; + uint16_t flags; }; const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { - [NOP] = { true, INSTR_FMT_IX, 0 }, - [RESUME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, - [LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, - [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, 0 }, - [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, - [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_CONST_FLAG }, - [STORE_FAST] = { true, INSTR_FMT_IB, 0 }, - [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, - [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, 0 }, - [POP_TOP] = { true, INSTR_FMT_IX, 0 }, - [PUSH_NULL] = { true, INSTR_FMT_IX, 0 }, - [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [END_SEND] = { true, INSTR_FMT_IX, 0 }, - [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [UNARY_NOT] = { true, INSTR_FMT_IX, 0 }, - [TO_BOOL_BOOL] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, - [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, - [TO_BOOL_LIST] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, - [TO_BOOL_NONE] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, - [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, - [TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, - [UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BEFORE_ASYNC_WITH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BEFORE_WITH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, + [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, + [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, + [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BINARY_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, [BINARY_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, - [SET_ADD] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [STORE_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_CONST_FLAG }, - [GET_AITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_ANEXT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_AWAITABLE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, - [POP_EXCEPT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [RERAISE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CLEANUP_THROW] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_ASSERTION_ERROR] = { true, INSTR_FMT_IX, 0 }, - [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, - [UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, - [UNPACK_SEQUENCE_LIST] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, - [UNPACK_EX] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_LOCALS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, - [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, - [COPY_FREE_VARS] = { true, INSTR_FMT_IB, 0 }, - [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_CONST_KEY_MAP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_CONST_KEY_MAP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DICT_MERGE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, 0 }, - [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [COMPARE_OP_FLOAT] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [COMPARE_OP_INT] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [COMPARE_OP_STR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [IS_OP] = { true, INSTR_FMT_IB, 0 }, - [CONTAINS_OP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_JUMP_FLAG }, - [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, - [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_JUMP_FLAG }, - [GET_LEN] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [MATCH_MAPPING] = { true, INSTR_FMT_IX, 0 }, - [MATCH_SEQUENCE] = { true, INSTR_FMT_IX, 0 }, - [MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [FOR_ITER_GEN] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [BEFORE_ASYNC_WITH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BEFORE_WITH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [PUSH_EXC_INFO] = { true, INSTR_FMT_IX, 0 }, - [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_PY_WITH_DEFAULTS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_DEOPT_FLAG }, - [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CACHE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [CALL] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_KW] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_KW] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, - [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, - [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [CALL_PY_WITH_DEFAULTS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_DEOPT_FLAG }, + [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CLEANUP_THROW] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [COMPARE_OP_FLOAT] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [COMPARE_OP_INT] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [COMPARE_OP_STR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [CONTAINS_OP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, - [FORMAT_SIMPLE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [FORMAT_WITH_SPEC] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, [COPY] = { true, INSTR_FMT_IB, 0 }, - [SWAP] = { true, INSTR_FMT_IB, 0 }, - [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, 0 }, - [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, 0 }, - [EXTENDED_ARG] = { true, INSTR_FMT_IB, 0 }, - [CACHE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [RESERVED] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [END_FOR] = { true, INSTR_FMT_IX, 0 }, - [TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_CONST_FLAG }, - [SEND] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, - [UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC000, HAS_DEOPT_FLAG }, - [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_DEOPT_FLAG }, - [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [COPY_FREE_VARS] = { true, INSTR_FMT_IB, 0 }, + [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, + [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DICT_MERGE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [END_FOR] = { true, INSTR_FMT_IX, 0 }, + [END_SEND] = { true, INSTR_FMT_IX, 0 }, + [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [EXTENDED_ARG] = { true, INSTR_FMT_IB, 0 }, + [FORMAT_SIMPLE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [FORMAT_WITH_SPEC] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, + [FOR_ITER_GEN] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [GET_AITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_ANEXT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_AWAITABLE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_LEN] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, + [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, 0 }, + [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, 0 }, + [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_CONST_FLAG }, + [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [IS_OP] = { true, INSTR_FMT_IB, 0 }, + [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, + [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_JUMP_FLAG }, + [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_JUMP_FLAG }, + [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, + [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_ASSERTION_ERROR] = { true, INSTR_FMT_IX, 0 }, [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, [LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, + [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, [LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, + [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_CONST_FLAG }, + [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, + [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, 0 }, + [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, + [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, + [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_DEOPT_FLAG }, + [LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC000, HAS_DEOPT_FLAG }, + [LOAD_LOCALS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [MATCH_MAPPING] = { true, INSTR_FMT_IX, 0 }, + [MATCH_SEQUENCE] = { true, INSTR_FMT_IX, 0 }, + [NOP] = { true, INSTR_FMT_IX, 0 }, + [POP_EXCEPT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, [POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, [POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, [POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, - [FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, - [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, - [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, - [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, - [LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [CALL] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, + [POP_TOP] = { true, INSTR_FMT_IX, 0 }, + [PUSH_EXC_INFO] = { true, INSTR_FMT_IX, 0 }, + [PUSH_NULL] = { true, INSTR_FMT_IX, 0 }, + [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RERAISE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RESERVED] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [RESUME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, + [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_CONST_FLAG }, + [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [SEND] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, + [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [SET_ADD] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, + [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, + [STORE_FAST] = { true, INSTR_FMT_IB, 0 }, + [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, + [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, 0 }, + [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [STORE_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [STORE_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [SWAP] = { true, INSTR_FMT_IB, 0 }, + [TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, + [TO_BOOL_BOOL] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, + [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, + [TO_BOOL_LIST] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, + [TO_BOOL_NONE] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, + [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, + [UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [UNARY_NOT] = { true, INSTR_FMT_IX, 0 }, + [UNPACK_EX] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [UNPACK_SEQUENCE_LIST] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, + [UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, + [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, + [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, }; #define MAX_UOP_PER_EXPANSION 9 @@ -813,6 +505,317 @@ _PyOpcode_macro_expansion[256] = { }; #endif // NEED_OPCODE_METADATA +extern const uint8_t _PyOpcode_Deopt[256]; +#ifdef NEED_OPCODE_METADATA +const uint8_t _PyOpcode_Deopt[256] = { + [NOP] = NOP, + [RESUME] = RESUME, + [RESUME_CHECK] = RESUME, + [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, + [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, + [LOAD_FAST] = LOAD_FAST, + [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, + [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, + [LOAD_CONST] = LOAD_CONST, + [STORE_FAST] = STORE_FAST, + [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, + [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, + [POP_TOP] = POP_TOP, + [PUSH_NULL] = PUSH_NULL, + [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, + [END_SEND] = END_SEND, + [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, + [UNARY_NEGATIVE] = UNARY_NEGATIVE, + [UNARY_NOT] = UNARY_NOT, + [TO_BOOL_BOOL] = TO_BOOL, + [TO_BOOL_INT] = TO_BOOL, + [TO_BOOL_LIST] = TO_BOOL, + [TO_BOOL_NONE] = TO_BOOL, + [TO_BOOL_STR] = TO_BOOL, + [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, + [UNARY_INVERT] = UNARY_INVERT, + [BINARY_SLICE] = BINARY_SLICE, + [STORE_SLICE] = STORE_SLICE, + [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, + [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, + [LIST_APPEND] = LIST_APPEND, + [SET_ADD] = SET_ADD, + [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, + [STORE_SUBSCR_DICT] = STORE_SUBSCR, + [DELETE_SUBSCR] = DELETE_SUBSCR, + [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, + [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, + [RAISE_VARARGS] = RAISE_VARARGS, + [INTERPRETER_EXIT] = INTERPRETER_EXIT, + [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, + [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST, + [GET_AITER] = GET_AITER, + [GET_ANEXT] = GET_ANEXT, + [GET_AWAITABLE] = GET_AWAITABLE, + [SEND_GEN] = SEND, + [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, + [YIELD_VALUE] = YIELD_VALUE, + [POP_EXCEPT] = POP_EXCEPT, + [RERAISE] = RERAISE, + [END_ASYNC_FOR] = END_ASYNC_FOR, + [CLEANUP_THROW] = CLEANUP_THROW, + [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, + [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, + [STORE_NAME] = STORE_NAME, + [DELETE_NAME] = DELETE_NAME, + [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, + [UNPACK_EX] = UNPACK_EX, + [DELETE_ATTR] = DELETE_ATTR, + [STORE_GLOBAL] = STORE_GLOBAL, + [DELETE_GLOBAL] = DELETE_GLOBAL, + [LOAD_LOCALS] = LOAD_LOCALS, + [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, + [LOAD_NAME] = LOAD_NAME, + [DELETE_FAST] = DELETE_FAST, + [MAKE_CELL] = MAKE_CELL, + [DELETE_DEREF] = DELETE_DEREF, + [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, + [LOAD_DEREF] = LOAD_DEREF, + [STORE_DEREF] = STORE_DEREF, + [COPY_FREE_VARS] = COPY_FREE_VARS, + [BUILD_STRING] = BUILD_STRING, + [BUILD_TUPLE] = BUILD_TUPLE, + [BUILD_LIST] = BUILD_LIST, + [LIST_EXTEND] = LIST_EXTEND, + [SET_UPDATE] = SET_UPDATE, + [BUILD_SET] = BUILD_SET, + [BUILD_MAP] = BUILD_MAP, + [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, + [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, + [DICT_UPDATE] = DICT_UPDATE, + [DICT_MERGE] = DICT_MERGE, + [MAP_ADD] = MAP_ADD, + [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, + [LOAD_ATTR_PROPERTY] = LOAD_ATTR, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, + [STORE_ATTR_WITH_HINT] = STORE_ATTR, + [COMPARE_OP_FLOAT] = COMPARE_OP, + [COMPARE_OP_INT] = COMPARE_OP, + [COMPARE_OP_STR] = COMPARE_OP, + [IS_OP] = IS_OP, + [CONTAINS_OP] = CONTAINS_OP, + [CHECK_EG_MATCH] = CHECK_EG_MATCH, + [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, + [IMPORT_NAME] = IMPORT_NAME, + [IMPORT_FROM] = IMPORT_FROM, + [JUMP_FORWARD] = JUMP_FORWARD, + [JUMP_BACKWARD] = JUMP_BACKWARD, + [ENTER_EXECUTOR] = ENTER_EXECUTOR, + [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, + [GET_LEN] = GET_LEN, + [MATCH_CLASS] = MATCH_CLASS, + [MATCH_MAPPING] = MATCH_MAPPING, + [MATCH_SEQUENCE] = MATCH_SEQUENCE, + [MATCH_KEYS] = MATCH_KEYS, + [GET_ITER] = GET_ITER, + [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, + [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, + [FOR_ITER_GEN] = FOR_ITER, + [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, + [BEFORE_WITH] = BEFORE_WITH, + [WITH_EXCEPT_START] = WITH_EXCEPT_START, + [PUSH_EXC_INFO] = PUSH_EXC_INFO, + [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, + [CALL_PY_WITH_DEFAULTS] = CALL, + [CALL_TYPE_1] = CALL, + [CALL_STR_1] = CALL, + [CALL_TUPLE_1] = CALL, + [CALL_ALLOC_AND_ENTER_INIT] = CALL, + [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, + [CALL_BUILTIN_CLASS] = CALL, + [CALL_BUILTIN_O] = CALL, + [CALL_BUILTIN_FAST] = CALL, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, + [CALL_LEN] = CALL, + [CALL_ISINSTANCE] = CALL, + [CALL_LIST_APPEND] = CALL, + [CALL_METHOD_DESCRIPTOR_O] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, + [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST] = CALL, + [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, + [CALL_KW] = CALL_KW, + [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, + [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, + [MAKE_FUNCTION] = MAKE_FUNCTION, + [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, + [RETURN_GENERATOR] = RETURN_GENERATOR, + [BUILD_SLICE] = BUILD_SLICE, + [CONVERT_VALUE] = CONVERT_VALUE, + [FORMAT_SIMPLE] = FORMAT_SIMPLE, + [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC, + [COPY] = COPY, + [SWAP] = SWAP, + [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, + [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, + [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, + [EXTENDED_ARG] = EXTENDED_ARG, + [CACHE] = CACHE, + [RESERVED] = RESERVED, + [END_FOR] = END_FOR, + [TO_BOOL] = TO_BOOL, + [BINARY_OP_MULTIPLY_INT] = BINARY_OP, + [BINARY_OP_ADD_INT] = BINARY_OP, + [BINARY_OP_SUBTRACT_INT] = BINARY_OP, + [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, + [BINARY_OP_ADD_FLOAT] = BINARY_OP, + [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, + [BINARY_OP_ADD_UNICODE] = BINARY_OP, + [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, + [BINARY_SUBSCR] = BINARY_SUBSCR, + [STORE_SUBSCR] = STORE_SUBSCR, + [RETURN_VALUE] = RETURN_VALUE, + [RETURN_CONST] = RETURN_CONST, + [SEND] = SEND, + [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, + [STORE_ATTR] = STORE_ATTR, + [LOAD_GLOBAL] = LOAD_GLOBAL, + [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, + [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, + [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, + [LOAD_ATTR] = LOAD_ATTR, + [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, + [LOAD_ATTR_MODULE] = LOAD_ATTR, + [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, + [LOAD_ATTR_SLOT] = LOAD_ATTR, + [LOAD_ATTR_CLASS] = LOAD_ATTR, + [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, + [STORE_ATTR_SLOT] = STORE_ATTR, + [COMPARE_OP] = COMPARE_OP, + [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, + [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, + [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, + [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, + [FOR_ITER] = FOR_ITER, + [FOR_ITER_LIST] = FOR_ITER, + [FOR_ITER_TUPLE] = FOR_ITER, + [FOR_ITER_RANGE] = FOR_ITER, + [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, + [CALL] = CALL, + [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, + [CALL_PY_EXACT_ARGS] = CALL, + [BINARY_OP] = BINARY_OP, +}; + +#endif // NEED_OPCODE_METADATA +const uint8_t _PyOpcode_Caches[256] = { + [TO_BOOL_BOOL] = 3, + [TO_BOOL_INT] = 3, + [TO_BOOL_LIST] = 3, + [TO_BOOL_NONE] = 3, + [TO_BOOL_STR] = 3, + [TO_BOOL_ALWAYS_TRUE] = 3, + [BINARY_SUBSCR_LIST_INT] = 1, + [BINARY_SUBSCR_STR_INT] = 1, + [BINARY_SUBSCR_TUPLE_INT] = 1, + [BINARY_SUBSCR_DICT] = 1, + [BINARY_SUBSCR_GETITEM] = 1, + [STORE_SUBSCR_LIST_INT] = 1, + [STORE_SUBSCR_DICT] = 1, + [SEND_GEN] = 1, + [UNPACK_SEQUENCE_TWO_TUPLE] = 1, + [UNPACK_SEQUENCE_TUPLE] = 1, + [UNPACK_SEQUENCE_LIST] = 1, + [INSTRUMENTED_LOAD_SUPER_ATTR] = 1, + [LOAD_SUPER_ATTR_ATTR] = 1, + [LOAD_SUPER_ATTR_METHOD] = 1, + [LOAD_ATTR_PROPERTY] = 9, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = 9, + [STORE_ATTR_WITH_HINT] = 4, + [COMPARE_OP_FLOAT] = 1, + [COMPARE_OP_INT] = 1, + [COMPARE_OP_STR] = 1, + [JUMP_BACKWARD] = 1, + [INSTRUMENTED_FOR_ITER] = 1, + [FOR_ITER_GEN] = 1, + [INSTRUMENTED_CALL] = 3, + [CALL_PY_WITH_DEFAULTS] = 3, + [CALL_TYPE_1] = 3, + [CALL_STR_1] = 3, + [CALL_TUPLE_1] = 3, + [CALL_ALLOC_AND_ENTER_INIT] = 3, + [CALL_BUILTIN_CLASS] = 3, + [CALL_BUILTIN_O] = 3, + [CALL_BUILTIN_FAST] = 3, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = 3, + [CALL_LEN] = 3, + [CALL_ISINSTANCE] = 3, + [CALL_LIST_APPEND] = 3, + [CALL_METHOD_DESCRIPTOR_O] = 3, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = 3, + [CALL_METHOD_DESCRIPTOR_NOARGS] = 3, + [CALL_METHOD_DESCRIPTOR_FAST] = 3, + [INSTRUMENTED_JUMP_BACKWARD] = 1, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = 1, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = 1, + [INSTRUMENTED_POP_JUMP_IF_NONE] = 1, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = 1, + [TO_BOOL] = 3, + [BINARY_OP_MULTIPLY_INT] = 1, + [BINARY_OP_ADD_INT] = 1, + [BINARY_OP_SUBTRACT_INT] = 1, + [BINARY_OP_MULTIPLY_FLOAT] = 1, + [BINARY_OP_ADD_FLOAT] = 1, + [BINARY_OP_SUBTRACT_FLOAT] = 1, + [BINARY_OP_ADD_UNICODE] = 1, + [BINARY_OP_INPLACE_ADD_UNICODE] = 1, + [BINARY_SUBSCR] = 1, + [STORE_SUBSCR] = 1, + [SEND] = 1, + [UNPACK_SEQUENCE] = 1, + [STORE_ATTR] = 4, + [LOAD_GLOBAL] = 4, + [LOAD_GLOBAL_MODULE] = 4, + [LOAD_GLOBAL_BUILTIN] = 4, + [LOAD_SUPER_ATTR] = 1, + [LOAD_ATTR] = 9, + [LOAD_ATTR_INSTANCE_VALUE] = 9, + [LOAD_ATTR_MODULE] = 9, + [LOAD_ATTR_WITH_HINT] = 9, + [LOAD_ATTR_SLOT] = 9, + [LOAD_ATTR_CLASS] = 9, + [STORE_ATTR_INSTANCE_VALUE] = 4, + [STORE_ATTR_SLOT] = 4, + [COMPARE_OP] = 1, + [POP_JUMP_IF_TRUE] = 1, + [POP_JUMP_IF_FALSE] = 1, + [POP_JUMP_IF_NONE] = 1, + [POP_JUMP_IF_NOT_NONE] = 1, + [FOR_ITER] = 1, + [FOR_ITER_LIST] = 1, + [FOR_ITER_TUPLE] = 1, + [FOR_ITER_RANGE] = 1, + [LOAD_ATTR_METHOD_WITH_VALUES] = 9, + [LOAD_ATTR_METHOD_NO_DICT] = 9, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = 9, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = 9, + [LOAD_ATTR_METHOD_LAZY_DICT] = 9, + [CALL] = 3, + [CALL_BOUND_METHOD_EXACT_ARGS] = 3, + [CALL_PY_EXACT_ARGS] = 3, + [BINARY_OP] = 1, +}; + const char *_PyOpcode_OpName[268] = { [BEFORE_ASYNC_WITH] = "BEFORE_ASYNC_WITH", [BEFORE_WITH] = "BEFORE_WITH", diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 78813510935852..8d4428d1af2a93 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -44,10 +44,11 @@ "CONST", "NAME", "JUMP", - "LOCAL", - "ERROR", "FREE", + "LOCAL", + "EVAL_BREAK", "DEOPT", + "ERROR", "ESCAPES", ] @@ -140,7 +141,7 @@ def generate_metadata_table( out.emit("uint16_t flags;\n"); out.emit("};\n\n") out.emit("const struct opcode_metadata _PyOpcode_opcode_metadata[256] = {\n") - for inst in analysis.instructions.values(): + for inst in sorted(analysis.instructions.values(), key = lambda t:t.name): out.emit(f"[{inst.name}] = {{ true, {get_format(inst)}, {cflags(inst.properties)} }},\n") out.emit("};\n\n") @@ -235,20 +236,20 @@ def generate_opcode_metadata( with out.header_guard("Py_CORE_OPCODE_METADATA_H"): out.emit("#ifndef Py_BUILD_CORE\n") out.emit('# error "this header requires Py_BUILD_CORE define"\n') - out.emit("#endif\n") + out.emit("#endif\n\n") out.emit("#include // bool\n") out.emit('#include "opcode_ids.h"\n') generate_is_pseudo(analysis, out) - out.emit('#include "pycore_uops.h"\n') + out.emit('#include "pycore_uop_ids.h"\n') generate_instruction_formats(analysis, out) out.emit("#define IS_VALID_OPCODE(OP) \\\n") out.emit(" (((OP) >= 0) && ((OP) < 256) && \\\n") out.emit(" (_PyOpcode_opcode_metadata[(OP)].valid_entry))\n\n") generate_flag_macros(out) - generate_deopt_table(analysis, out) - generate_cache_table(analysis, out) generate_metadata_table(analysis, out) generate_expansion_table(analysis, out) + generate_deopt_table(analysis, out) + generate_cache_table(analysis, out) generate_name_table(analysis, out) generate_psuedo_targets(analysis, out) From b371413a07cc5c4bcf6eb7ef7815fd320a4c63d8 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 02:30:16 +0000 Subject: [PATCH 05/51] Reorganise a bit to reduce output diff --- Include/internal/pycore_opcode_metadata.h | 376 +++++++++--------- Include/internal/pycore_uop_metadata.h | 376 +++++++++--------- Tools/cases_generator/generators_common.py | 10 +- .../opcode_metadata_generator.py | 2 +- 4 files changed, 383 insertions(+), 381 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 23c222d7e4fab2..b39b24fd1e05f3 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -59,16 +59,16 @@ enum InstructionFormat { #define HAS_DEOPT_FLAG (128) #define HAS_ERROR_FLAG (256) #define HAS_ESCAPES_FLAG (512) -#define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) -#define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) -#define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) -#define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) -#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) -#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) -#define OPCODE_HAS_EVAL_BREAK(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_EVAL_BREAK_FLAG)) -#define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) -#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) -#define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) +#define OPCODE_HAS_ARG(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ARG_FLAG)) +#define OPCODE_HAS_CONST(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_CONST_FLAG)) +#define OPCODE_HAS_NAME(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_NAME_FLAG)) +#define OPCODE_HAS_JUMP(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_JUMP_FLAG)) +#define OPCODE_HAS_FREE(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_FREE_FLAG)) +#define OPCODE_HAS_LOCAL(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_LOCAL_FLAG)) +#define OPCODE_HAS_EVAL_BREAK(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_EVAL_BREAK_FLAG)) +#define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) +#define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) +#define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) struct opcode_metadata { uint8_t valid_entry; uint8_t instr_format; @@ -76,213 +76,213 @@ struct opcode_metadata { }; const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { - [BEFORE_ASYNC_WITH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BEFORE_WITH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BEFORE_ASYNC_WITH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BEFORE_WITH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, + [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BINARY_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, + [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, + [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [BINARY_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, - [BUILD_CONST_KEY_MAP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [BUILD_CONST_KEY_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_SET] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_SLICE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CACHE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [CALL] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_KW] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [CALL_PY_WITH_DEFAULTS] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_DEOPT_FLAG }, - [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CLEANUP_THROW] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [COMPARE_OP_FLOAT] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [COMPARE_OP_INT] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [COMPARE_OP_STR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [CONTAINS_OP] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, - [COPY] = { true, INSTR_FMT_IB, 0 }, - [COPY_FREE_VARS] = { true, INSTR_FMT_IB, 0 }, - [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, - [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DICT_MERGE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, + [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [CALL_PY_WITH_DEFAULTS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CLEANUP_THROW] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [COMPARE_OP_FLOAT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [COMPARE_OP_INT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [COMPARE_OP_STR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [CONTAINS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [COPY] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [COPY_FREE_VARS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DICT_MERGE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [END_FOR] = { true, INSTR_FMT_IX, 0 }, [END_SEND] = { true, INSTR_FMT_IX, 0 }, - [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [EXTENDED_ARG] = { true, INSTR_FMT_IB, 0 }, - [FORMAT_SIMPLE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [FORMAT_WITH_SPEC] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, - [FOR_ITER_GEN] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, - [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, - [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, - [GET_AITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_ANEXT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_AWAITABLE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_LEN] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [EXTENDED_ARG] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [FORMAT_SIMPLE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [FORMAT_WITH_SPEC] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [FOR_ITER_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [GET_AITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_ANEXT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_AWAITABLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_LEN] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, - [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, 0 }, - [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, 0 }, - [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_CONST_FLAG }, - [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_CONST_FLAG }, + [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [IS_OP] = { true, INSTR_FMT_IB, 0 }, - [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, - [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_JUMP_FLAG }, - [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_JUMP_FLAG }, - [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, - [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [IS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_ASSERTION_ERROR] = { true, INSTR_FMT_IX, 0 }, - [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_DEOPT_FLAG }, - [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_CONST_FLAG }, - [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, - [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, 0 }, - [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ERROR_FLAG }, - [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, - [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_DEOPT_FLAG }, - [LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC000, HAS_DEOPT_FLAG }, - [LOAD_LOCALS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, + [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [LOAD_LOCALS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MATCH_MAPPING] = { true, INSTR_FMT_IX, 0 }, [MATCH_SEQUENCE] = { true, INSTR_FMT_IX, 0 }, [NOP] = { true, INSTR_FMT_IX, 0 }, [POP_EXCEPT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, - [POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, - [POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, - [POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_JUMP_FLAG }, + [POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG }, [POP_TOP] = { true, INSTR_FMT_IX, 0 }, [PUSH_EXC_INFO] = { true, INSTR_FMT_IX, 0 }, [PUSH_NULL] = { true, INSTR_FMT_IX, 0 }, - [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [RERAISE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [RERAISE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RESERVED] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [RESUME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_CONST_FLAG }, - [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG | HAS_CONST_FLAG }, + [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [SEND] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG }, - [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [SET_ADD] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, - [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, - [STORE_FAST] = { true, INSTR_FMT_IB, 0 }, - [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, 0 }, - [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, 0 }, - [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [STORE_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG }, - [STORE_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG }, - [SWAP] = { true, INSTR_FMT_IB, 0 }, - [TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [SET_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, + [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, + [STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [SWAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_BOOL] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_LIST] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_NONE] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_DEOPT_FLAG }, - [UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, + [UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [UNARY_NOT] = { true, INSTR_FMT_IX, 0 }, - [UNPACK_EX] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [UNPACK_SEQUENCE_LIST] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, - [UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, - [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_DEOPT_FLAG }, - [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_ERROR_FLAG }, - [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ESCAPES_FLAG }, + [UNPACK_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [UNPACK_SEQUENCE_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, + [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, }; #define MAX_UOP_PER_EXPANSION 9 diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index acf03621bb0ca6..e2258e6f20c17f 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -17,33 +17,33 @@ extern const char * const _PyOpcode_uop_name[MAX_UOP_ID+1]; #ifdef NEED_OPCODE_METADATA const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_NOP] = 0, - [_RESUME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_RESUME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_RESUME_CHECK] = HAS_DEOPT_FLAG, - [_INSTRUMENTED_RESUME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_LOAD_FAST_CHECK] = HAS_ERROR_FLAG, - [_LOAD_FAST] = 0, - [_LOAD_FAST_AND_CLEAR] = 0, - [_LOAD_FAST_LOAD_FAST] = 0, - [_LOAD_CONST] = HAS_CONST_FLAG, - [_STORE_FAST] = 0, - [_STORE_FAST_LOAD_FAST] = 0, - [_STORE_FAST_STORE_FAST] = 0, + [_INSTRUMENTED_RESUME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FAST_CHECK] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_LOAD_FAST] = HAS_ARG_FLAG, + [_LOAD_FAST_AND_CLEAR] = HAS_ARG_FLAG, + [_LOAD_FAST_LOAD_FAST] = HAS_ARG_FLAG, + [_LOAD_CONST] = HAS_ARG_FLAG | HAS_CONST_FLAG, + [_STORE_FAST] = HAS_ARG_FLAG, + [_STORE_FAST_LOAD_FAST] = HAS_ARG_FLAG, + [_STORE_FAST_STORE_FAST] = HAS_ARG_FLAG, [_POP_TOP] = 0, [_PUSH_NULL] = 0, - [_INSTRUMENTED_END_FOR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_INSTRUMENTED_END_FOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_END_SEND] = 0, - [_INSTRUMENTED_END_SEND] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_UNARY_NEGATIVE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_INSTRUMENTED_END_SEND] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_UNARY_NEGATIVE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_UNARY_NOT] = 0, [_SPECIALIZE_TO_BOOL] = HAS_ESCAPES_FLAG, - [_TO_BOOL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_TO_BOOL] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_TO_BOOL_BOOL] = HAS_DEOPT_FLAG, [_TO_BOOL_INT] = HAS_DEOPT_FLAG, [_TO_BOOL_LIST] = HAS_DEOPT_FLAG, [_TO_BOOL_NONE] = HAS_DEOPT_FLAG, [_TO_BOOL_STR] = HAS_DEOPT_FLAG, [_TO_BOOL_ALWAYS_TRUE] = HAS_DEOPT_FLAG, - [_UNARY_INVERT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_UNARY_INVERT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GUARD_BOTH_INT] = HAS_DEOPT_FLAG, [_BINARY_OP_MULTIPLY_INT] = HAS_ERROR_FLAG, [_BINARY_OP_ADD_INT] = HAS_ERROR_FLAG, @@ -53,213 +53,213 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BINARY_OP_ADD_FLOAT] = 0, [_BINARY_OP_SUBTRACT_FLOAT] = 0, [_GUARD_BOTH_UNICODE] = HAS_DEOPT_FLAG, - [_BINARY_OP_ADD_UNICODE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, + [_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SPECIALIZE_BINARY_SUBSCR] = HAS_ESCAPES_FLAG, - [_BINARY_SUBSCR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BINARY_SLICE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_STORE_SLICE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BINARY_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BINARY_SUBSCR_LIST_INT] = HAS_DEOPT_FLAG, [_BINARY_SUBSCR_STR_INT] = HAS_DEOPT_FLAG, [_BINARY_SUBSCR_TUPLE_INT] = HAS_DEOPT_FLAG, - [_BINARY_SUBSCR_DICT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_BINARY_SUBSCR_GETITEM] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_LIST_APPEND] = HAS_ERROR_FLAG, - [_SET_ADD] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_BINARY_SUBSCR_DICT] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_SUBSCR_GETITEM] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LIST_APPEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_SET_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SPECIALIZE_STORE_SUBSCR] = HAS_ESCAPES_FLAG, - [_STORE_SUBSCR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_STORE_SUBSCR_LIST_INT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_STORE_SUBSCR_DICT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_DELETE_SUBSCR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CALL_INTRINSIC_1] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CALL_INTRINSIC_2] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_RAISE_VARARGS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_STORE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_SUBSCR_LIST_INT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_STORE_SUBSCR_DICT] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_RAISE_VARARGS] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_INTERPRETER_EXIT] = HAS_ESCAPES_FLAG, [_POP_FRAME] = HAS_ESCAPES_FLAG, - [_INSTRUMENTED_RETURN_VALUE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_INSTRUMENTED_RETURN_CONST] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_CONST_FLAG, - [_GET_AITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_GET_ANEXT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_GET_AWAITABLE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_INSTRUMENTED_RETURN_VALUE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_INSTRUMENTED_RETURN_CONST] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_CONST_FLAG, + [_GET_AITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GET_AWAITABLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SPECIALIZE_SEND] = HAS_ESCAPES_FLAG, - [_SEND] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG, - [_SEND_GEN] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_INSTRUMENTED_YIELD_VALUE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_YIELD_VALUE] = HAS_ESCAPES_FLAG, + [_SEND] = HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SEND_GEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_INSTRUMENTED_YIELD_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_YIELD_VALUE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_POP_EXCEPT] = HAS_ESCAPES_FLAG, - [_RERAISE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_END_ASYNC_FOR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CLEANUP_THROW] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_RERAISE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_END_ASYNC_FOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CLEANUP_THROW] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_ASSERTION_ERROR] = 0, - [_LOAD_BUILD_CLASS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_STORE_NAME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_DELETE_NAME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_SPECIALIZE_UNPACK_SEQUENCE] = HAS_ESCAPES_FLAG, - [_UNPACK_SEQUENCE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_UNPACK_SEQUENCE_TWO_TUPLE] = HAS_DEOPT_FLAG, - [_UNPACK_SEQUENCE_TUPLE] = HAS_DEOPT_FLAG, - [_UNPACK_SEQUENCE_LIST] = HAS_DEOPT_FLAG, - [_UNPACK_EX] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_SPECIALIZE_STORE_ATTR] = HAS_ESCAPES_FLAG, - [_STORE_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_DELETE_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_STORE_GLOBAL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_DELETE_GLOBAL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_LOAD_LOCALS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_LOAD_FROM_DICT_OR_GLOBALS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_LOAD_NAME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_SPECIALIZE_LOAD_GLOBAL] = HAS_ESCAPES_FLAG, - [_LOAD_GLOBAL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_BUILD_CLASS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_NAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_NAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_UNPACK_SEQUENCE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_UNPACK_SEQUENCE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_UNPACK_SEQUENCE_TWO_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_UNPACK_SEQUENCE_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_UNPACK_SEQUENCE_LIST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_UNPACK_EX] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_STORE_ATTR] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_STORE_ATTR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_ATTR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_GLOBAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_GLOBAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_LOCALS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FROM_DICT_OR_GLOBALS] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_NAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GUARD_GLOBALS_VERSION] = HAS_DEOPT_FLAG, [_GUARD_BUILTINS_VERSION] = HAS_DEOPT_FLAG, - [_LOAD_GLOBAL_MODULE] = HAS_DEOPT_FLAG, - [_LOAD_GLOBAL_BUILTINS] = HAS_DEOPT_FLAG, - [_DELETE_FAST] = HAS_ERROR_FLAG, - [_MAKE_CELL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_DELETE_DEREF] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_LOAD_FROM_DICT_OR_DEREF] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_LOAD_DEREF] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_STORE_DEREF] = HAS_ESCAPES_FLAG, - [_COPY_FREE_VARS] = 0, - [_BUILD_STRING] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BUILD_TUPLE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BUILD_LIST] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_LIST_EXTEND] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_SET_UPDATE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BUILD_SET] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BUILD_MAP] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_SETUP_ANNOTATIONS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BUILD_CONST_KEY_MAP] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_DICT_UPDATE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_DICT_MERGE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_MAP_ADD] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_INSTRUMENTED_LOAD_SUPER_ATTR] = 0, - [_SPECIALIZE_LOAD_SUPER_ATTR] = HAS_ESCAPES_FLAG, - [_LOAD_SUPER_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_LOAD_SUPER_ATTR_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_LOAD_SUPER_ATTR_METHOD] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_SPECIALIZE_LOAD_ATTR] = HAS_ESCAPES_FLAG, - [_LOAD_ATTR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_LOAD_GLOBAL_MODULE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_LOAD_GLOBAL_BUILTINS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_DELETE_FAST] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_MAKE_CELL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_DEREF] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FROM_DICT_OR_DEREF] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_DEREF] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_DEREF] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_COPY_FREE_VARS] = HAS_ARG_FLAG, + [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_LIST] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LIST_EXTEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SET_UPDATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_SET] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_MAP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SETUP_ANNOTATIONS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_CONST_KEY_MAP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DICT_UPDATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DICT_MERGE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MAP_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_INSTRUMENTED_LOAD_SUPER_ATTR] = HAS_ARG_FLAG, + [_SPECIALIZE_LOAD_SUPER_ATTR] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR_ATTR] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR_METHOD] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_LOAD_ATTR] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GUARD_TYPE_VERSION] = HAS_DEOPT_FLAG, [_CHECK_MANAGED_OBJECT_HAS_VALUES] = HAS_DEOPT_FLAG, - [_LOAD_ATTR_INSTANCE_VALUE] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_INSTANCE_VALUE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_CHECK_ATTR_MODULE] = HAS_DEOPT_FLAG, - [_LOAD_ATTR_MODULE] = HAS_DEOPT_FLAG, - [_CHECK_ATTR_WITH_HINT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_LOAD_ATTR_WITH_HINT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_LOAD_ATTR_SLOT] = HAS_DEOPT_FLAG, + [_LOAD_ATTR_MODULE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_CHECK_ATTR_WITH_HINT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_SLOT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_CHECK_ATTR_CLASS] = HAS_DEOPT_FLAG, - [_LOAD_ATTR_CLASS] = 0, - [_LOAD_ATTR_PROPERTY] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_LOAD_ATTR_CLASS] = HAS_ARG_FLAG, + [_LOAD_ATTR_PROPERTY] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_GUARD_DORV_VALUES] = HAS_DEOPT_FLAG, [_STORE_ATTR_INSTANCE_VALUE] = HAS_ESCAPES_FLAG, - [_STORE_ATTR_WITH_HINT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, + [_STORE_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_STORE_ATTR_SLOT] = HAS_ESCAPES_FLAG, - [_SPECIALIZE_COMPARE_OP] = HAS_ESCAPES_FLAG, - [_COMPARE_OP] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_COMPARE_OP_FLOAT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_COMPARE_OP_INT] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_COMPARE_OP_STR] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_IS_OP] = 0, - [_CONTAINS_OP] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CHECK_EG_MATCH] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CHECK_EXC_MATCH] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_IMPORT_NAME] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_IMPORT_FROM] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_JUMP_FORWARD] = HAS_JUMP_FLAG, - [_JUMP_BACKWARD] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG, - [_ENTER_EXECUTOR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_POP_JUMP_IF_FALSE] = HAS_JUMP_FLAG, - [_POP_JUMP_IF_TRUE] = HAS_JUMP_FLAG, + [_SPECIALIZE_COMPARE_OP] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_COMPARE_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_COMPARE_OP_FLOAT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_COMPARE_OP_INT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_COMPARE_OP_STR] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_IS_OP] = HAS_ARG_FLAG, + [_CONTAINS_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_EG_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_EXC_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_IMPORT_NAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_IMPORT_FROM] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_JUMP_FORWARD] = HAS_ARG_FLAG | HAS_JUMP_FLAG, + [_JUMP_BACKWARD] = HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_ENTER_EXECUTOR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_POP_JUMP_IF_FALSE] = HAS_ARG_FLAG | HAS_JUMP_FLAG, + [_POP_JUMP_IF_TRUE] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_IS_NONE] = 0, - [_JUMP_BACKWARD_NO_INTERRUPT] = HAS_JUMP_FLAG, - [_GET_LEN] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_MATCH_CLASS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_JUMP_BACKWARD_NO_INTERRUPT] = HAS_ARG_FLAG | HAS_JUMP_FLAG, + [_GET_LEN] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MATCH_CLASS] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MATCH_MAPPING] = 0, [_MATCH_SEQUENCE] = 0, - [_MATCH_KEYS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_GET_ITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_GET_YIELD_FROM_ITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_SPECIALIZE_FOR_ITER] = HAS_ESCAPES_FLAG, - [_FOR_ITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_JUMP_FLAG, - [_FOR_ITER_TIER_TWO] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_INSTRUMENTED_FOR_ITER] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_MATCH_KEYS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GET_ITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_GET_YIELD_FROM_ITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_FOR_ITER] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_FOR_ITER] = HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_FOR_ITER_TIER_TWO] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_INSTRUMENTED_FOR_ITER] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_ITER_CHECK_LIST] = HAS_DEOPT_FLAG, - [_ITER_JUMP_LIST] = HAS_JUMP_FLAG, + [_ITER_JUMP_LIST] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_GUARD_NOT_EXHAUSTED_LIST] = HAS_DEOPT_FLAG, [_ITER_NEXT_LIST] = 0, [_ITER_CHECK_TUPLE] = HAS_DEOPT_FLAG, - [_ITER_JUMP_TUPLE] = HAS_JUMP_FLAG, + [_ITER_JUMP_TUPLE] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_GUARD_NOT_EXHAUSTED_TUPLE] = HAS_DEOPT_FLAG, [_ITER_NEXT_TUPLE] = 0, [_ITER_CHECK_RANGE] = HAS_DEOPT_FLAG, - [_ITER_JUMP_RANGE] = HAS_JUMP_FLAG, + [_ITER_JUMP_RANGE] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_GUARD_NOT_EXHAUSTED_RANGE] = HAS_DEOPT_FLAG, - [_ITER_NEXT_RANGE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_FOR_ITER_GEN] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_BEFORE_ASYNC_WITH] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BEFORE_WITH] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_WITH_EXCEPT_START] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_ITER_NEXT_RANGE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_FOR_ITER_GEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_BEFORE_ASYNC_WITH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BEFORE_WITH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_WITH_EXCEPT_START] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_PUSH_EXC_INFO] = 0, [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = HAS_DEOPT_FLAG, [_GUARD_KEYS_VERSION] = HAS_DEOPT_FLAG, - [_LOAD_ATTR_METHOD_WITH_VALUES] = HAS_ESCAPES_FLAG, - [_LOAD_ATTR_METHOD_NO_DICT] = HAS_ESCAPES_FLAG, - [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = 0, - [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = 0, + [_LOAD_ATTR_METHOD_WITH_VALUES] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_METHOD_NO_DICT] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = HAS_ARG_FLAG, + [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = HAS_ARG_FLAG, [_CHECK_ATTR_METHOD_LAZY_DICT] = HAS_DEOPT_FLAG, - [_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ESCAPES_FLAG, - [_INSTRUMENTED_CALL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_SPECIALIZE_CALL] = HAS_ESCAPES_FLAG, - [_CALL] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = HAS_DEOPT_FLAG, - [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = 0, + [_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_INSTRUMENTED_CALL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_CALL] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_CALL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = HAS_ARG_FLAG, [_CHECK_PEP_523] = HAS_DEOPT_FLAG, - [_CHECK_FUNCTION_EXACT_ARGS] = HAS_DEOPT_FLAG, - [_CHECK_STACK_SPACE] = HAS_DEOPT_FLAG, - [_INIT_CALL_PY_EXACT_ARGS] = HAS_ESCAPES_FLAG, + [_CHECK_FUNCTION_EXACT_ARGS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_CHECK_STACK_SPACE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_INIT_CALL_PY_EXACT_ARGS] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_PUSH_FRAME] = 0, - [_CALL_PY_WITH_DEFAULTS] = HAS_ESCAPES_FLAG | HAS_DEOPT_FLAG, - [_CALL_TYPE_1] = HAS_DEOPT_FLAG, - [_CALL_STR_1] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_TUPLE_1] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_ALLOC_AND_ENTER_INIT] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_EXIT_INIT_CHECK] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CALL_BUILTIN_CLASS] = HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_BUILTIN_O] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_BUILTIN_FAST] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_LEN] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_ISINSTANCE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_LIST_APPEND] = HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_METHOD_DESCRIPTOR_O] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG | HAS_DEOPT_FLAG, - [_INSTRUMENTED_CALL_KW] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CALL_KW] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, + [_CALL_PY_WITH_DEFAULTS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_CALL_TYPE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, + [_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_ALLOC_AND_ENTER_INIT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, + [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_LEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_ISINSTANCE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_LIST_APPEND] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, + [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_INSTRUMENTED_CALL_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_INSTRUMENTED_CALL_FUNCTION_EX] = 0, - [_CALL_FUNCTION_EX] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_MAKE_FUNCTION] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_SET_FUNCTION_ATTRIBUTE] = HAS_ESCAPES_FLAG, - [_RETURN_GENERATOR] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_BUILD_SLICE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_CONVERT_VALUE] = HAS_ERROR_FLAG, - [_FORMAT_SIMPLE] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_FORMAT_WITH_SPEC] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_COPY] = 0, - [_SPECIALIZE_BINARY_OP] = HAS_ESCAPES_FLAG, - [_BINARY_OP] = HAS_ERROR_FLAG, - [_SWAP] = 0, - [_INSTRUMENTED_INSTRUCTION] = HAS_ESCAPES_FLAG | HAS_ERROR_FLAG, - [_INSTRUMENTED_JUMP_FORWARD] = 0, - [_INSTRUMENTED_JUMP_BACKWARD] = 0, - [_INSTRUMENTED_POP_JUMP_IF_TRUE] = 0, - [_INSTRUMENTED_POP_JUMP_IF_FALSE] = 0, - [_INSTRUMENTED_POP_JUMP_IF_NONE] = 0, - [_INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = 0, - [_EXTENDED_ARG] = 0, + [_CALL_FUNCTION_EX] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_FORMAT_WITH_SPEC] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_COPY] = HAS_ARG_FLAG, + [_SPECIALIZE_BINARY_OP] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_SWAP] = HAS_ARG_FLAG, + [_INSTRUMENTED_INSTRUCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_INSTRUMENTED_JUMP_FORWARD] = HAS_ARG_FLAG, + [_INSTRUMENTED_JUMP_BACKWARD] = HAS_ARG_FLAG, + [_INSTRUMENTED_POP_JUMP_IF_TRUE] = HAS_ARG_FLAG, + [_INSTRUMENTED_POP_JUMP_IF_FALSE] = HAS_ARG_FLAG, + [_INSTRUMENTED_POP_JUMP_IF_NONE] = HAS_ARG_FLAG, + [_INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = HAS_ARG_FLAG, + [_EXTENDED_ARG] = HAS_ARG_FLAG, [_CACHE] = HAS_ESCAPES_FLAG, [_RESERVED] = HAS_ESCAPES_FLAG, [_GUARD_IS_TRUE_POP] = HAS_DEOPT_FLAG, @@ -267,10 +267,10 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_GUARD_IS_NONE_POP] = HAS_DEOPT_FLAG, [_GUARD_IS_NOT_NONE_POP] = HAS_DEOPT_FLAG, [_JUMP_TO_TOP] = 0, - [_SET_IP] = HAS_ESCAPES_FLAG, - [_SAVE_RETURN_OFFSET] = 0, + [_SET_IP] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_SAVE_RETURN_OFFSET] = HAS_ARG_FLAG, [_EXIT_TRACE] = HAS_DEOPT_FLAG, - [_INSERT] = 0, + [_INSERT] = HAS_ARG_FLAG, [_CHECK_VALIDITY] = HAS_DEOPT_FLAG, }; diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index e060ed813e24c4..33539d1bfaab97 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -188,14 +188,16 @@ def emit_tokens( def cflags(p: Properties) -> str: flags: list[str] = [] - if p.escapes: - flags.append("HAS_ESCAPES_FLAG") - if not p.infallible: - flags.append("HAS_ERROR_FLAG") + if p.oparg: + flags.append("HAS_ARG_FLAG") if p.deopts: flags.append("HAS_DEOPT_FLAG") if p.jumps: flags.append("HAS_JUMP_FLAG") + if not p.infallible: + flags.append("HAS_ERROR_FLAG") + if p.escapes: + flags.append("HAS_ESCAPES_FLAG") if p.uses_co_consts: flags.append("HAS_CONST_FLAG") if flags: diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 8d4428d1af2a93..710990abd39298 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -56,7 +56,7 @@ def generate_flag_macros(out: CWriter) -> None: for i, flag in enumerate(FLAGS): out.emit(f"#define HAS_{flag}_FLAG ({1< Date: Thu, 14 Dec 2023 02:36:20 +0000 Subject: [PATCH 06/51] Reorganise a bit to reduce output diff --- Include/internal/pycore_opcode_metadata.h | 50 ++++++++++---------- Include/internal/pycore_uop_metadata.h | 54 +++++++++++----------- Tools/cases_generator/analyzer.py | 8 ++++ Tools/cases_generator/generators_common.py | 8 +++- 4 files changed, 66 insertions(+), 54 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index b39b24fd1e05f3..53c8ad587f191e 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -136,11 +136,11 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [COPY] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [COPY_FREE_VARS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [DICT_MERGE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -163,8 +163,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [GET_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [GET_LEN] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -180,7 +180,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_CONST_FLAG }, + [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, @@ -191,9 +191,9 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [LIST_EXTEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_ASSERTION_ERROR] = { true, INSTR_FMT_IX, 0 }, - [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, @@ -203,25 +203,25 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, - [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, - [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [LOAD_GLOBAL_MODULE] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [LOAD_LOCALS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -242,7 +242,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [RESERVED] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, - [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG | HAS_CONST_FLAG }, + [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ESCAPES_FLAG }, [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, [SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -251,16 +251,16 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [SET_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, + [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG }, [STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [STORE_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [STORE_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index e2258e6f20c17f..d658e5ebe35c9a 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -77,7 +77,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_INTERPRETER_EXIT] = HAS_ESCAPES_FLAG, [_POP_FRAME] = HAS_ESCAPES_FLAG, [_INSTRUMENTED_RETURN_VALUE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_RETURN_CONST] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_CONST_FLAG, + [_INSTRUMENTED_RETURN_CONST] = HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_AITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_AWAITABLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -92,34 +92,34 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CLEANUP_THROW] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_ASSERTION_ERROR] = 0, [_LOAD_BUILD_CLASS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_STORE_NAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_DELETE_NAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SPECIALIZE_UNPACK_SEQUENCE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_UNPACK_SEQUENCE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_UNPACK_SEQUENCE_TWO_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_UNPACK_SEQUENCE_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_UNPACK_SEQUENCE_LIST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_UNPACK_EX] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_STORE_ATTR] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_STORE_ATTR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_DELETE_ATTR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_STORE_GLOBAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_DELETE_GLOBAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_STORE_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG, + [_STORE_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_LOCALS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_FROM_DICT_OR_GLOBALS] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_NAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FROM_DICT_OR_GLOBALS] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GUARD_GLOBALS_VERSION] = HAS_DEOPT_FLAG, [_GUARD_BUILTINS_VERSION] = HAS_DEOPT_FLAG, [_LOAD_GLOBAL_MODULE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_LOAD_GLOBAL_BUILTINS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_DELETE_FAST] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_MAKE_CELL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_DELETE_DEREF] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_FROM_DICT_OR_DEREF] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_DEREF] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_STORE_DEREF] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_MAKE_CELL] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FROM_DICT_OR_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -135,26 +135,26 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_MAP_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_INSTRUMENTED_LOAD_SUPER_ATTR] = HAS_ARG_FLAG, [_SPECIALIZE_LOAD_SUPER_ATTR] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_SUPER_ATTR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_SUPER_ATTR_ATTR] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_SUPER_ATTR_METHOD] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_LOAD_ATTR] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_ATTR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_SUPER_ATTR_METHOD] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_SPECIALIZE_LOAD_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GUARD_TYPE_VERSION] = HAS_DEOPT_FLAG, [_CHECK_MANAGED_OBJECT_HAS_VALUES] = HAS_DEOPT_FLAG, [_LOAD_ATTR_INSTANCE_VALUE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_CHECK_ATTR_MODULE] = HAS_DEOPT_FLAG, [_LOAD_ATTR_MODULE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_CHECK_ATTR_WITH_HINT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_LOAD_ATTR_SLOT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_CHECK_ATTR_CLASS] = HAS_DEOPT_FLAG, [_LOAD_ATTR_CLASS] = HAS_ARG_FLAG, [_LOAD_ATTR_PROPERTY] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_GUARD_DORV_VALUES] = HAS_DEOPT_FLAG, [_STORE_ATTR_INSTANCE_VALUE] = HAS_ESCAPES_FLAG, - [_STORE_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_STORE_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_STORE_ATTR_SLOT] = HAS_ESCAPES_FLAG, [_SPECIALIZE_COMPARE_OP] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_COMPARE_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -165,8 +165,8 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CONTAINS_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_EG_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_EXC_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_IMPORT_NAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_IMPORT_FROM] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_IMPORT_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_IMPORT_FROM] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_JUMP_FORWARD] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_JUMP_BACKWARD] = HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_ENTER_EXECUTOR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 2edb00ba00b3c2..48be566ee87cca 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -19,6 +19,7 @@ class Properties: uses_co_consts: bool uses_co_names: bool uses_locals: bool + has_free: bool def dump(self, indent: str) -> None: print(indent, end="") @@ -41,6 +42,7 @@ def from_list(properties: list["Properties"]) -> "Properties": uses_co_consts=any(p.uses_co_consts for p in properties), uses_co_names=any(p.uses_co_names for p in properties), uses_locals=any(p.uses_locals for p in properties), + has_free=any(p.has_free for p in properties), ) @@ -58,6 +60,7 @@ def from_list(properties: list["Properties"]) -> "Properties": uses_co_consts=False, uses_co_names=False, uses_locals=False, + has_free=False, ) @@ -337,6 +340,11 @@ def compute_properties(op: parser.InstDef) -> Properties: uses_co_consts=variable_used(op, "FRAME_CO_CONSTS"), uses_co_names=variable_used(op, "FRAME_CO_NAMES"), uses_locals=variable_used(op, "GETLOCAL") or variable_used(op, "SETLOCAL"), + has_free = ( + variable_used(op, "PyCell_New") + or variable_used(op, "PyCell_GET") + or variable_used(op, "PyCell_SET") + ), ) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 33539d1bfaab97..1ecf9564a57aaf 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -190,16 +190,20 @@ def cflags(p: Properties) -> str: flags: list[str] = [] if p.oparg: flags.append("HAS_ARG_FLAG") + if p.uses_co_consts: + flags.append("HAS_CONST_FLAG") + if p.uses_co_names: + flags.append("HAS_NAME_FLAG") if p.deopts: flags.append("HAS_DEOPT_FLAG") if p.jumps: flags.append("HAS_JUMP_FLAG") + if p.has_free: + flags.append("HAS_FREE_FLAG") if not p.infallible: flags.append("HAS_ERROR_FLAG") if p.escapes: flags.append("HAS_ESCAPES_FLAG") - if p.uses_co_consts: - flags.append("HAS_CONST_FLAG") if flags: return " | ".join(flags) else: From 2831b75fbb83ad6650255167e918c0ed03b3dfaf Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 02:37:35 +0000 Subject: [PATCH 07/51] Reorganise a bit to reduce output diff --- Include/internal/pycore_opcode_metadata.h | 28 +++++++++++----------- Include/internal/pycore_uop_metadata.h | 28 +++++++++++----------- Tools/cases_generator/generators_common.py | 2 ++ 3 files changed, 30 insertions(+), 28 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 53c8ad587f191e..7eac2336746385 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -82,7 +82,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, @@ -137,8 +137,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [COPY] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [COPY_FREE_VARS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG }, [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [DELETE_SUBSCR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -206,12 +206,12 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, - [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG }, + [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, @@ -221,7 +221,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -255,10 +255,10 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG }, - [STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, + [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG }, + [STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, [STORE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [STORE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [STORE_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index d658e5ebe35c9a..150d12f67d5e47 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -20,14 +20,14 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_RESUME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_RESUME_CHECK] = HAS_DEOPT_FLAG, [_INSTRUMENTED_RESUME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_FAST_CHECK] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_LOAD_FAST] = HAS_ARG_FLAG, - [_LOAD_FAST_AND_CLEAR] = HAS_ARG_FLAG, - [_LOAD_FAST_LOAD_FAST] = HAS_ARG_FLAG, + [_LOAD_FAST_CHECK] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG, + [_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, + [_LOAD_FAST_AND_CLEAR] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, + [_LOAD_FAST_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, [_LOAD_CONST] = HAS_ARG_FLAG | HAS_CONST_FLAG, - [_STORE_FAST] = HAS_ARG_FLAG, - [_STORE_FAST_LOAD_FAST] = HAS_ARG_FLAG, - [_STORE_FAST_STORE_FAST] = HAS_ARG_FLAG, + [_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, + [_STORE_FAST_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, + [_STORE_FAST_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, [_POP_TOP] = 0, [_PUSH_NULL] = 0, [_INSTRUMENTED_END_FOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -54,7 +54,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BINARY_OP_SUBTRACT_FLOAT] = 0, [_GUARD_BOTH_UNICODE] = HAS_DEOPT_FLAG, [_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_DEOPT_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SPECIALIZE_BINARY_SUBSCR] = HAS_ESCAPES_FLAG, [_BINARY_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -114,12 +114,12 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_GUARD_BUILTINS_VERSION] = HAS_DEOPT_FLAG, [_LOAD_GLOBAL_MODULE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_LOAD_GLOBAL_BUILTINS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, - [_DELETE_FAST] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_MAKE_CELL] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_DELETE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_FROM_DICT_OR_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG, + [_MAKE_CELL] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FROM_DICT_OR_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 1ecf9564a57aaf..ad995b6a004ee5 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -200,6 +200,8 @@ def cflags(p: Properties) -> str: flags.append("HAS_JUMP_FLAG") if p.has_free: flags.append("HAS_FREE_FLAG") + if p.uses_locals: + flags.append("HAS_LOCAL_FLAG") if not p.infallible: flags.append("HAS_ERROR_FLAG") if p.escapes: From e8014d2af458a7890d2c4694341eb472e240af07 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 02:57:04 +0000 Subject: [PATCH 08/51] Reorganise a bit to reduce output diff --- Include/internal/pycore_opcode_metadata.h | 18 +++++++++--------- Include/internal/pycore_uop_metadata.h | 12 ++++++------ Tools/cases_generator/analyzer.py | 13 +++++++------ Tools/cases_generator/generators_common.py | 6 +++--- 4 files changed, 25 insertions(+), 24 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 7eac2336746385..8fc30ae24f1b21 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -82,7 +82,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, @@ -137,7 +137,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [COPY] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [COPY_FREE_VARS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [DELETE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [DELETE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG }, [DELETE_GLOBAL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [DELETE_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -154,9 +154,9 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [FORMAT_WITH_SPEC] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [FOR_ITER_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, - [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_JUMP_FLAG }, + [FOR_ITER_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_DEOPT_FLAG }, + [FOR_ITER_RANGE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [FOR_ITER_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_DEOPT_FLAG }, [GET_AITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [GET_ANEXT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [GET_AWAITABLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -206,12 +206,12 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, - [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, [LOAD_FAST_AND_CLEAR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, [LOAD_FAST_CHECK] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG }, [LOAD_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, - [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_FROM_DICT_OR_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_FROM_DICT_OR_GLOBALS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_GLOBAL] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_GLOBAL_BUILTIN] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, @@ -221,7 +221,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -255,7 +255,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [STORE_ATTR_SLOT] = { true, INSTR_FMT_IXC000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [STORE_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG }, + [STORE_DEREF] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG }, [STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, [STORE_FAST_LOAD_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, [STORE_FAST_STORE_FAST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 150d12f67d5e47..f228d05917223c 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -54,7 +54,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BINARY_OP_SUBTRACT_FLOAT] = 0, [_GUARD_BOTH_UNICODE] = HAS_DEOPT_FLAG, [_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_DEOPT_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SPECIALIZE_BINARY_SUBSCR] = HAS_ESCAPES_FLAG, [_BINARY_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -115,11 +115,11 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_LOAD_GLOBAL_MODULE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_LOAD_GLOBAL_BUILTINS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_DELETE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG, - [_MAKE_CELL] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_DELETE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_FROM_DICT_OR_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG, + [_MAKE_CELL] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_DELETE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_FROM_DICT_OR_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_STORE_DEREF] = HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ESCAPES_FLAG, [_COPY_FREE_VARS] = HAS_ARG_FLAG, [_BUILD_STRING] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 48be566ee87cca..db615933a4b129 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -326,6 +326,11 @@ def always_exits(op: parser.InstDef) -> bool: def compute_properties(op: parser.InstDef) -> Properties: + has_free = ( + variable_used(op, "PyCell_New") + or variable_used(op, "PyCell_GET") + or variable_used(op, "PyCell_SET") + ) return Properties( escapes=makes_escaping_api_call(op), infallible=is_infallible(op), @@ -339,12 +344,8 @@ def compute_properties(op: parser.InstDef) -> Properties: tier_one_only=variable_used(op, "TIER_ONE_ONLY"), uses_co_consts=variable_used(op, "FRAME_CO_CONSTS"), uses_co_names=variable_used(op, "FRAME_CO_NAMES"), - uses_locals=variable_used(op, "GETLOCAL") or variable_used(op, "SETLOCAL"), - has_free = ( - variable_used(op, "PyCell_New") - or variable_used(op, "PyCell_GET") - or variable_used(op, "PyCell_SET") - ), + uses_locals= not has_free and (variable_used(op, "GETLOCAL") or variable_used(op, "SETLOCAL")), + has_free=has_free, ) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index ad995b6a004ee5..de80fe02ac8571 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -194,14 +194,14 @@ def cflags(p: Properties) -> str: flags.append("HAS_CONST_FLAG") if p.uses_co_names: flags.append("HAS_NAME_FLAG") - if p.deopts: - flags.append("HAS_DEOPT_FLAG") if p.jumps: flags.append("HAS_JUMP_FLAG") if p.has_free: flags.append("HAS_FREE_FLAG") - if p.uses_locals: + elif p.uses_locals: flags.append("HAS_LOCAL_FLAG") + if p.deopts: + flags.append("HAS_DEOPT_FLAG") if not p.infallible: flags.append("HAS_ERROR_FLAG") if p.escapes: From 04ffe4e441fb771f93f315fc653f498ad8136229 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 03:00:47 +0000 Subject: [PATCH 09/51] Reorganise a bit to reduce output diff --- Include/internal/pycore_opcode_metadata.h | 414 +++++++++--------- .../opcode_metadata_generator.py | 2 +- 2 files changed, 208 insertions(+), 208 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 8fc30ae24f1b21..c59628876b1200 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -295,213 +295,213 @@ _PyOpcode_macro_expansion[256]; #ifdef NEED_OPCODE_METADATA const struct opcode_macro_expansion _PyOpcode_macro_expansion[256] = { - [BEFORE_ASYNC_WITH] = { .nops = 1, .uops = { { _BEFORE_ASYNC_WITH 0, 0 } }}, - [BEFORE_WITH] = { .nops = 1, .uops = { { _BEFORE_WITH 0, 0 } }}, - [BINARY_OP] = { .nops = 0, .uops = { }}, - [BINARY_OP_ADD_FLOAT] = { .nops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_ADD_FLOAT 1, 0 } }}, - [BINARY_OP_ADD_INT] = { .nops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_ADD_INT 1, 0 } }}, - [BINARY_OP_ADD_UNICODE] = { .nops = 2, .uops = { { _GUARD_BOTH_UNICODE 0, 0 }, { _BINARY_OP_ADD_UNICODE 1, 0 } }}, - [BINARY_OP_INPLACE_ADD_UNICODE] = { .nops = 2, .uops = { { _GUARD_BOTH_UNICODE 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE 1, 0 } }}, - [BINARY_OP_MULTIPLY_FLOAT] = { .nops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT 1, 0 } }}, - [BINARY_OP_MULTIPLY_INT] = { .nops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_MULTIPLY_INT 1, 0 } }}, - [BINARY_OP_SUBTRACT_FLOAT] = { .nops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT 1, 0 } }}, - [BINARY_OP_SUBTRACT_INT] = { .nops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_SUBTRACT_INT 1, 0 } }}, - [BINARY_SLICE] = { .nops = 1, .uops = { { _BINARY_SLICE 0, 0 } }}, - [BINARY_SUBSCR] = { .nops = 0, .uops = { }}, - [BINARY_SUBSCR_DICT] = { .nops = 1, .uops = { { _BINARY_SUBSCR_DICT 1, 0 } }}, - [BINARY_SUBSCR_GETITEM] = { .nops = 0, .uops = { }}, - [BINARY_SUBSCR_LIST_INT] = { .nops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT 1, 0 } }}, - [BINARY_SUBSCR_STR_INT] = { .nops = 1, .uops = { { _BINARY_SUBSCR_STR_INT 1, 0 } }}, - [BINARY_SUBSCR_TUPLE_INT] = { .nops = 1, .uops = { { _BINARY_SUBSCR_TUPLE_INT 1, 0 } }}, - [BUILD_CONST_KEY_MAP] = { .nops = 1, .uops = { { _BUILD_CONST_KEY_MAP 0, 0 } }}, - [BUILD_LIST] = { .nops = 1, .uops = { { _BUILD_LIST 0, 0 } }}, - [BUILD_MAP] = { .nops = 1, .uops = { { _BUILD_MAP 0, 0 } }}, - [BUILD_SET] = { .nops = 1, .uops = { { _BUILD_SET 0, 0 } }}, - [BUILD_SLICE] = { .nops = 1, .uops = { { _BUILD_SLICE 0, 0 } }}, - [BUILD_STRING] = { .nops = 1, .uops = { { _BUILD_STRING 0, 0 } }}, - [BUILD_TUPLE] = { .nops = 1, .uops = { { _BUILD_TUPLE 0, 0 } }}, - [CACHE] = { .nops = 1, .uops = { { _CACHE 0, 0 } }}, - [CALL] = { .nops = 0, .uops = { }}, - [CALL_ALLOC_AND_ENTER_INIT] = { .nops = 0, .uops = { }}, - [CALL_BOUND_METHOD_EXACT_ARGS] = { .nops = 9, .uops = { { unused/1 1, 0 }, { _CHECK_PEP_523 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS 2, 1 }, { _CHECK_STACK_SPACE 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS 0, 0 }, { _SAVE_RETURN_OFFSET 7, 3 }, { _PUSH_FRAME 0, 0 } }}, - [CALL_BUILTIN_CLASS] = { .nops = 1, .uops = { { _CALL_BUILTIN_CLASS 3, 0 } }}, - [CALL_BUILTIN_FAST] = { .nops = 1, .uops = { { _CALL_BUILTIN_FAST 3, 0 } }}, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { .nops = 1, .uops = { { _CALL_BUILTIN_FAST_WITH_KEYWORDS 3, 0 } }}, - [CALL_BUILTIN_O] = { .nops = 1, .uops = { { _CALL_BUILTIN_O 3, 0 } }}, - [CALL_FUNCTION_EX] = { .nops = 0, .uops = { }}, - [CALL_INTRINSIC_1] = { .nops = 1, .uops = { { _CALL_INTRINSIC_1 0, 0 } }}, - [CALL_INTRINSIC_2] = { .nops = 1, .uops = { { _CALL_INTRINSIC_2 0, 0 } }}, - [CALL_ISINSTANCE] = { .nops = 1, .uops = { { _CALL_ISINSTANCE 3, 0 } }}, - [CALL_KW] = { .nops = 0, .uops = { }}, - [CALL_LEN] = { .nops = 1, .uops = { { _CALL_LEN 3, 0 } }}, - [CALL_LIST_APPEND] = { .nops = 1, .uops = { { _CALL_LIST_APPEND 3, 0 } }}, - [CALL_METHOD_DESCRIPTOR_FAST] = { .nops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST 3, 0 } }}, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 3, 0 } }}, - [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_NOARGS 3, 0 } }}, - [CALL_METHOD_DESCRIPTOR_O] = { .nops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_O 3, 0 } }}, - [CALL_PY_EXACT_ARGS] = { .nops = 7, .uops = { { unused/1 1, 0 }, { _CHECK_PEP_523 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS 2, 1 }, { _CHECK_STACK_SPACE 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS 0, 0 }, { _SAVE_RETURN_OFFSET 7, 3 }, { _PUSH_FRAME 0, 0 } }}, - [CALL_PY_WITH_DEFAULTS] = { .nops = 0, .uops = { }}, - [CALL_STR_1] = { .nops = 1, .uops = { { _CALL_STR_1 3, 0 } }}, - [CALL_TUPLE_1] = { .nops = 1, .uops = { { _CALL_TUPLE_1 3, 0 } }}, - [CALL_TYPE_1] = { .nops = 1, .uops = { { _CALL_TYPE_1 3, 0 } }}, - [CHECK_EG_MATCH] = { .nops = 1, .uops = { { _CHECK_EG_MATCH 0, 0 } }}, - [CHECK_EXC_MATCH] = { .nops = 1, .uops = { { _CHECK_EXC_MATCH 0, 0 } }}, - [CLEANUP_THROW] = { .nops = 0, .uops = { }}, - [COMPARE_OP] = { .nops = 0, .uops = { }}, - [COMPARE_OP_FLOAT] = { .nops = 1, .uops = { { _COMPARE_OP_FLOAT 1, 0 } }}, - [COMPARE_OP_INT] = { .nops = 1, .uops = { { _COMPARE_OP_INT 1, 0 } }}, - [COMPARE_OP_STR] = { .nops = 1, .uops = { { _COMPARE_OP_STR 1, 0 } }}, - [CONTAINS_OP] = { .nops = 1, .uops = { { _CONTAINS_OP 0, 0 } }}, - [CONVERT_VALUE] = { .nops = 1, .uops = { { _CONVERT_VALUE 0, 0 } }}, - [COPY] = { .nops = 1, .uops = { { _COPY 0, 0 } }}, - [COPY_FREE_VARS] = { .nops = 1, .uops = { { _COPY_FREE_VARS 0, 0 } }}, - [DELETE_ATTR] = { .nops = 1, .uops = { { _DELETE_ATTR 0, 0 } }}, - [DELETE_DEREF] = { .nops = 1, .uops = { { _DELETE_DEREF 0, 0 } }}, - [DELETE_FAST] = { .nops = 1, .uops = { { _DELETE_FAST 0, 0 } }}, - [DELETE_GLOBAL] = { .nops = 1, .uops = { { _DELETE_GLOBAL 0, 0 } }}, - [DELETE_NAME] = { .nops = 1, .uops = { { _DELETE_NAME 0, 0 } }}, - [DELETE_SUBSCR] = { .nops = 1, .uops = { { _DELETE_SUBSCR 0, 0 } }}, - [DICT_MERGE] = { .nops = 1, .uops = { { _DICT_MERGE 0, 0 } }}, - [DICT_UPDATE] = { .nops = 1, .uops = { { _DICT_UPDATE 0, 0 } }}, - [END_ASYNC_FOR] = { .nops = 0, .uops = { }}, - [END_FOR] = { .nops = 2, .uops = { { _POP_TOP 0, 0 }, { _POP_TOP 0, 0 } }}, - [END_SEND] = { .nops = 1, .uops = { { _END_SEND 0, 0 } }}, - [ENTER_EXECUTOR] = { .nops = 1, .uops = { { _ENTER_EXECUTOR 0, 0 } }}, - [EXIT_INIT_CHECK] = { .nops = 1, .uops = { { _EXIT_INIT_CHECK 0, 0 } }}, - [EXTENDED_ARG] = { .nops = 1, .uops = { { _EXTENDED_ARG 0, 0 } }}, - [FORMAT_SIMPLE] = { .nops = 1, .uops = { { _FORMAT_SIMPLE 0, 0 } }}, - [FORMAT_WITH_SPEC] = { .nops = 1, .uops = { { _FORMAT_WITH_SPEC 0, 0 } }}, - [FOR_ITER] = { .nops = 0, .uops = { }}, - [FOR_ITER_GEN] = { .nops = 0, .uops = { }}, - [FOR_ITER_LIST] = { .nops = 0, .uops = { }}, - [FOR_ITER_RANGE] = { .nops = 0, .uops = { }}, - [FOR_ITER_TUPLE] = { .nops = 0, .uops = { }}, - [GET_AITER] = { .nops = 1, .uops = { { _GET_AITER 0, 0 } }}, - [GET_ANEXT] = { .nops = 1, .uops = { { _GET_ANEXT 0, 0 } }}, - [GET_AWAITABLE] = { .nops = 1, .uops = { { _GET_AWAITABLE 0, 0 } }}, - [GET_ITER] = { .nops = 1, .uops = { { _GET_ITER 0, 0 } }}, - [GET_LEN] = { .nops = 1, .uops = { { _GET_LEN 0, 0 } }}, - [GET_YIELD_FROM_ITER] = { .nops = 1, .uops = { { _GET_YIELD_FROM_ITER 0, 0 } }}, - [IMPORT_FROM] = { .nops = 1, .uops = { { _IMPORT_FROM 0, 0 } }}, - [IMPORT_NAME] = { .nops = 1, .uops = { { _IMPORT_NAME 0, 0 } }}, - [INSTRUMENTED_CALL] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_CALL_FUNCTION_EX] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_CALL_KW] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_END_FOR] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_END_SEND] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_FOR_ITER] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_INSTRUCTION] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_JUMP_BACKWARD] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_JUMP_FORWARD] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_LOAD_SUPER_ATTR] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_POP_JUMP_IF_NONE] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_RESUME] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_RETURN_CONST] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_RETURN_VALUE] = { .nops = 0, .uops = { }}, - [INSTRUMENTED_YIELD_VALUE] = { .nops = 0, .uops = { }}, - [INTERPRETER_EXIT] = { .nops = 1, .uops = { { _INTERPRETER_EXIT 0, 0 } }}, - [IS_OP] = { .nops = 1, .uops = { { _IS_OP 0, 0 } }}, - [JUMP_BACKWARD] = { .nops = 0, .uops = { }}, - [JUMP_BACKWARD_NO_INTERRUPT] = { .nops = 1, .uops = { { _JUMP_BACKWARD_NO_INTERRUPT 0, 0 } }}, - [JUMP_FORWARD] = { .nops = 1, .uops = { { _JUMP_FORWARD 0, 0 } }}, - [LIST_APPEND] = { .nops = 1, .uops = { { _LIST_APPEND 0, 0 } }}, - [LIST_EXTEND] = { .nops = 1, .uops = { { _LIST_EXTEND 0, 0 } }}, - [LOAD_ASSERTION_ERROR] = { .nops = 1, .uops = { { _LOAD_ASSERTION_ERROR 0, 0 } }}, - [LOAD_ATTR] = { .nops = 0, .uops = { }}, - [LOAD_ATTR_CLASS] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _CHECK_ATTR_CLASS 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_CLASS 4, 5 } }}, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { .nops = 0, .uops = { }}, - [LOAD_ATTR_INSTANCE_VALUE] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE 1, 3 }, { unused/5 5, 4 } }}, - [LOAD_ATTR_METHOD_LAZY_DICT] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT 0, 0 }, { unused/2 2, 3 }, { _LOAD_ATTR_METHOD_LAZY_DICT 4, 5 } }}, - [LOAD_ATTR_METHOD_NO_DICT] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_METHOD_NO_DICT 4, 5 } }}, - [LOAD_ATTR_METHOD_WITH_VALUES] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 0, 0 }, { _GUARD_KEYS_VERSION 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES 4, 5 } }}, - [LOAD_ATTR_MODULE] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _CHECK_ATTR_MODULE 2, 1 }, { _LOAD_ATTR_MODULE 1, 3 }, { unused/5 5, 4 } }}, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 4, 5 } }}, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 0, 0 }, { _GUARD_KEYS_VERSION 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 4, 5 } }}, - [LOAD_ATTR_PROPERTY] = { .nops = 0, .uops = { }}, - [LOAD_ATTR_SLOT] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _LOAD_ATTR_SLOT 1, 3 }, { unused/5 5, 4 } }}, - [LOAD_ATTR_WITH_HINT] = { .nops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_ATTR_WITH_HINT 0, 0 }, { _LOAD_ATTR_WITH_HINT 1, 3 }, { unused/5 5, 4 } }}, - [LOAD_BUILD_CLASS] = { .nops = 1, .uops = { { _LOAD_BUILD_CLASS 0, 0 } }}, - [LOAD_CONST] = { .nops = 1, .uops = { { _LOAD_CONST 0, 0 } }}, - [LOAD_DEREF] = { .nops = 1, .uops = { { _LOAD_DEREF 0, 0 } }}, - [LOAD_FAST] = { .nops = 1, .uops = { { _LOAD_FAST 0, 0 } }}, - [LOAD_FAST_AND_CLEAR] = { .nops = 1, .uops = { { _LOAD_FAST_AND_CLEAR 0, 0 } }}, - [LOAD_FAST_CHECK] = { .nops = 1, .uops = { { _LOAD_FAST_CHECK 0, 0 } }}, - [LOAD_FAST_LOAD_FAST] = { .nops = 2, .uops = { { _LOAD_FAST 5, 0 }, { _LOAD_FAST 6, 0 } }}, - [LOAD_FROM_DICT_OR_DEREF] = { .nops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF 0, 0 } }}, - [LOAD_FROM_DICT_OR_GLOBALS] = { .nops = 1, .uops = { { _LOAD_FROM_DICT_OR_GLOBALS 0, 0 } }}, - [LOAD_GLOBAL] = { .nops = 0, .uops = { }}, - [LOAD_GLOBAL_BUILTIN] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_GLOBALS_VERSION 1, 1 }, { _GUARD_BUILTINS_VERSION 1, 2 }, { _LOAD_GLOBAL_BUILTINS 1, 3 } }}, - [LOAD_GLOBAL_MODULE] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_GLOBALS_VERSION 1, 1 }, { unused/1 1, 2 }, { _LOAD_GLOBAL_MODULE 1, 3 } }}, - [LOAD_LOCALS] = { .nops = 1, .uops = { { _LOAD_LOCALS 0, 0 } }}, - [LOAD_NAME] = { .nops = 1, .uops = { { _LOAD_NAME 0, 0 } }}, - [LOAD_SUPER_ATTR] = { .nops = 0, .uops = { }}, - [LOAD_SUPER_ATTR_ATTR] = { .nops = 1, .uops = { { _LOAD_SUPER_ATTR_ATTR 1, 0 } }}, - [LOAD_SUPER_ATTR_METHOD] = { .nops = 1, .uops = { { _LOAD_SUPER_ATTR_METHOD 1, 0 } }}, - [MAKE_CELL] = { .nops = 1, .uops = { { _MAKE_CELL 0, 0 } }}, - [MAKE_FUNCTION] = { .nops = 1, .uops = { { _MAKE_FUNCTION 0, 0 } }}, - [MAP_ADD] = { .nops = 1, .uops = { { _MAP_ADD 0, 0 } }}, - [MATCH_CLASS] = { .nops = 1, .uops = { { _MATCH_CLASS 0, 0 } }}, - [MATCH_KEYS] = { .nops = 1, .uops = { { _MATCH_KEYS 0, 0 } }}, - [MATCH_MAPPING] = { .nops = 1, .uops = { { _MATCH_MAPPING 0, 0 } }}, - [MATCH_SEQUENCE] = { .nops = 1, .uops = { { _MATCH_SEQUENCE 0, 0 } }}, - [NOP] = { .nops = 1, .uops = { { _NOP 0, 0 } }}, - [POP_EXCEPT] = { .nops = 1, .uops = { { _POP_EXCEPT 0, 0 } }}, - [POP_JUMP_IF_FALSE] = { .nops = 0, .uops = { }}, - [POP_JUMP_IF_NONE] = { .nops = 0, .uops = { }}, - [POP_JUMP_IF_NOT_NONE] = { .nops = 0, .uops = { }}, - [POP_JUMP_IF_TRUE] = { .nops = 0, .uops = { }}, - [POP_TOP] = { .nops = 1, .uops = { { _POP_TOP 0, 0 } }}, - [PUSH_EXC_INFO] = { .nops = 1, .uops = { { _PUSH_EXC_INFO 0, 0 } }}, - [PUSH_NULL] = { .nops = 1, .uops = { { _PUSH_NULL 0, 0 } }}, - [RAISE_VARARGS] = { .nops = 0, .uops = { }}, - [RERAISE] = { .nops = 0, .uops = { }}, - [RESERVED] = { .nops = 1, .uops = { { _RESERVED 0, 0 } }}, - [RESUME] = { .nops = 0, .uops = { }}, - [RESUME_CHECK] = { .nops = 1, .uops = { { _RESUME_CHECK 0, 0 } }}, - [RETURN_CONST] = { .nops = 2, .uops = { { _LOAD_CONST 0, 0 }, { _POP_FRAME 0, 0 } }}, - [RETURN_GENERATOR] = { .nops = 1, .uops = { { _RETURN_GENERATOR 0, 0 } }}, - [RETURN_VALUE] = { .nops = 1, .uops = { { _POP_FRAME 0, 0 } }}, - [SEND] = { .nops = 0, .uops = { }}, - [SEND_GEN] = { .nops = 0, .uops = { }}, - [SETUP_ANNOTATIONS] = { .nops = 1, .uops = { { _SETUP_ANNOTATIONS 0, 0 } }}, - [SET_ADD] = { .nops = 1, .uops = { { _SET_ADD 0, 0 } }}, - [SET_FUNCTION_ATTRIBUTE] = { .nops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE 0, 0 } }}, - [SET_UPDATE] = { .nops = 1, .uops = { { _SET_UPDATE 0, 0 } }}, - [STORE_ATTR] = { .nops = 0, .uops = { }}, - [STORE_ATTR_INSTANCE_VALUE] = { .nops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE 1, 3 } }}, - [STORE_ATTR_SLOT] = { .nops = 3, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _STORE_ATTR_SLOT 1, 3 } }}, - [STORE_ATTR_WITH_HINT] = { .nops = 0, .uops = { }}, - [STORE_DEREF] = { .nops = 1, .uops = { { _STORE_DEREF 0, 0 } }}, - [STORE_FAST] = { .nops = 1, .uops = { { _STORE_FAST 0, 0 } }}, - [STORE_FAST_LOAD_FAST] = { .nops = 2, .uops = { { _STORE_FAST 5, 0 }, { _LOAD_FAST 6, 0 } }}, - [STORE_FAST_STORE_FAST] = { .nops = 2, .uops = { { _STORE_FAST 5, 0 }, { _STORE_FAST 6, 0 } }}, - [STORE_GLOBAL] = { .nops = 1, .uops = { { _STORE_GLOBAL 0, 0 } }}, - [STORE_NAME] = { .nops = 1, .uops = { { _STORE_NAME 0, 0 } }}, - [STORE_SLICE] = { .nops = 1, .uops = { { _STORE_SLICE 0, 0 } }}, - [STORE_SUBSCR] = { .nops = 0, .uops = { }}, - [STORE_SUBSCR_DICT] = { .nops = 1, .uops = { { _STORE_SUBSCR_DICT 1, 0 } }}, - [STORE_SUBSCR_LIST_INT] = { .nops = 1, .uops = { { _STORE_SUBSCR_LIST_INT 1, 0 } }}, - [SWAP] = { .nops = 1, .uops = { { _SWAP 0, 0 } }}, - [TO_BOOL] = { .nops = 0, .uops = { }}, - [TO_BOOL_ALWAYS_TRUE] = { .nops = 1, .uops = { { _TO_BOOL_ALWAYS_TRUE 3, 0 } }}, - [TO_BOOL_BOOL] = { .nops = 1, .uops = { { _TO_BOOL_BOOL 3, 0 } }}, - [TO_BOOL_INT] = { .nops = 1, .uops = { { _TO_BOOL_INT 3, 0 } }}, - [TO_BOOL_LIST] = { .nops = 1, .uops = { { _TO_BOOL_LIST 3, 0 } }}, - [TO_BOOL_NONE] = { .nops = 1, .uops = { { _TO_BOOL_NONE 3, 0 } }}, - [TO_BOOL_STR] = { .nops = 1, .uops = { { _TO_BOOL_STR 3, 0 } }}, - [UNARY_INVERT] = { .nops = 1, .uops = { { _UNARY_INVERT 0, 0 } }}, - [UNARY_NEGATIVE] = { .nops = 1, .uops = { { _UNARY_NEGATIVE 0, 0 } }}, - [UNARY_NOT] = { .nops = 1, .uops = { { _UNARY_NOT 0, 0 } }}, - [UNPACK_EX] = { .nops = 1, .uops = { { _UNPACK_EX 0, 0 } }}, - [UNPACK_SEQUENCE] = { .nops = 0, .uops = { }}, - [UNPACK_SEQUENCE_LIST] = { .nops = 1, .uops = { { _UNPACK_SEQUENCE_LIST 1, 0 } }}, - [UNPACK_SEQUENCE_TUPLE] = { .nops = 1, .uops = { { _UNPACK_SEQUENCE_TUPLE 1, 0 } }}, - [UNPACK_SEQUENCE_TWO_TUPLE] = { .nops = 1, .uops = { { _UNPACK_SEQUENCE_TWO_TUPLE 1, 0 } }}, - [WITH_EXCEPT_START] = { .nops = 1, .uops = { { _WITH_EXCEPT_START 0, 0 } }}, - [YIELD_VALUE] = { .nops = 1, .uops = { { _YIELD_VALUE 0, 0 } }}, + [BEFORE_ASYNC_WITH] = { .nuops = 1, .uops = { { _BEFORE_ASYNC_WITH 0, 0 } } }, + [BEFORE_WITH] = { .nuops = 1, .uops = { { _BEFORE_WITH 0, 0 } } }, + [BINARY_OP] = { .nuops = 0, .uops = { } }, + [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_ADD_FLOAT 1, 0 } } }, + [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_ADD_INT 1, 0 } } }, + [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE 0, 0 }, { _BINARY_OP_ADD_UNICODE 1, 0 } } }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE 1, 0 } } }, + [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT 1, 0 } } }, + [BINARY_OP_MULTIPLY_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_MULTIPLY_INT 1, 0 } } }, + [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT 1, 0 } } }, + [BINARY_OP_SUBTRACT_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_SUBTRACT_INT 1, 0 } } }, + [BINARY_SLICE] = { .nuops = 1, .uops = { { _BINARY_SLICE 0, 0 } } }, + [BINARY_SUBSCR] = { .nuops = 0, .uops = { } }, + [BINARY_SUBSCR_DICT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_DICT 1, 0 } } }, + [BINARY_SUBSCR_GETITEM] = { .nuops = 0, .uops = { } }, + [BINARY_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT 1, 0 } } }, + [BINARY_SUBSCR_STR_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_STR_INT 1, 0 } } }, + [BINARY_SUBSCR_TUPLE_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_TUPLE_INT 1, 0 } } }, + [BUILD_CONST_KEY_MAP] = { .nuops = 1, .uops = { { _BUILD_CONST_KEY_MAP 0, 0 } } }, + [BUILD_LIST] = { .nuops = 1, .uops = { { _BUILD_LIST 0, 0 } } }, + [BUILD_MAP] = { .nuops = 1, .uops = { { _BUILD_MAP 0, 0 } } }, + [BUILD_SET] = { .nuops = 1, .uops = { { _BUILD_SET 0, 0 } } }, + [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE 0, 0 } } }, + [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING 0, 0 } } }, + [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE 0, 0 } } }, + [CACHE] = { .nuops = 1, .uops = { { _CACHE 0, 0 } } }, + [CALL] = { .nuops = 0, .uops = { } }, + [CALL_ALLOC_AND_ENTER_INIT] = { .nuops = 0, .uops = { } }, + [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 9, .uops = { { unused/1 1, 0 }, { _CHECK_PEP_523 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS 2, 1 }, { _CHECK_STACK_SPACE 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS 0, 0 }, { _SAVE_RETURN_OFFSET 7, 3 }, { _PUSH_FRAME 0, 0 } } }, + [CALL_BUILTIN_CLASS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_CLASS 3, 0 } } }, + [CALL_BUILTIN_FAST] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST 3, 0 } } }, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST_WITH_KEYWORDS 3, 0 } } }, + [CALL_BUILTIN_O] = { .nuops = 1, .uops = { { _CALL_BUILTIN_O 3, 0 } } }, + [CALL_FUNCTION_EX] = { .nuops = 0, .uops = { } }, + [CALL_INTRINSIC_1] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_1 0, 0 } } }, + [CALL_INTRINSIC_2] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_2 0, 0 } } }, + [CALL_ISINSTANCE] = { .nuops = 1, .uops = { { _CALL_ISINSTANCE 3, 0 } } }, + [CALL_KW] = { .nuops = 0, .uops = { } }, + [CALL_LEN] = { .nuops = 1, .uops = { { _CALL_LEN 3, 0 } } }, + [CALL_LIST_APPEND] = { .nuops = 1, .uops = { { _CALL_LIST_APPEND 3, 0 } } }, + [CALL_METHOD_DESCRIPTOR_FAST] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST 3, 0 } } }, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 3, 0 } } }, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_NOARGS 3, 0 } } }, + [CALL_METHOD_DESCRIPTOR_O] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_O 3, 0 } } }, + [CALL_PY_EXACT_ARGS] = { .nuops = 7, .uops = { { unused/1 1, 0 }, { _CHECK_PEP_523 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS 2, 1 }, { _CHECK_STACK_SPACE 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS 0, 0 }, { _SAVE_RETURN_OFFSET 7, 3 }, { _PUSH_FRAME 0, 0 } } }, + [CALL_PY_WITH_DEFAULTS] = { .nuops = 0, .uops = { } }, + [CALL_STR_1] = { .nuops = 1, .uops = { { _CALL_STR_1 3, 0 } } }, + [CALL_TUPLE_1] = { .nuops = 1, .uops = { { _CALL_TUPLE_1 3, 0 } } }, + [CALL_TYPE_1] = { .nuops = 1, .uops = { { _CALL_TYPE_1 3, 0 } } }, + [CHECK_EG_MATCH] = { .nuops = 1, .uops = { { _CHECK_EG_MATCH 0, 0 } } }, + [CHECK_EXC_MATCH] = { .nuops = 1, .uops = { { _CHECK_EXC_MATCH 0, 0 } } }, + [CLEANUP_THROW] = { .nuops = 0, .uops = { } }, + [COMPARE_OP] = { .nuops = 0, .uops = { } }, + [COMPARE_OP_FLOAT] = { .nuops = 1, .uops = { { _COMPARE_OP_FLOAT 1, 0 } } }, + [COMPARE_OP_INT] = { .nuops = 1, .uops = { { _COMPARE_OP_INT 1, 0 } } }, + [COMPARE_OP_STR] = { .nuops = 1, .uops = { { _COMPARE_OP_STR 1, 0 } } }, + [CONTAINS_OP] = { .nuops = 1, .uops = { { _CONTAINS_OP 0, 0 } } }, + [CONVERT_VALUE] = { .nuops = 1, .uops = { { _CONVERT_VALUE 0, 0 } } }, + [COPY] = { .nuops = 1, .uops = { { _COPY 0, 0 } } }, + [COPY_FREE_VARS] = { .nuops = 1, .uops = { { _COPY_FREE_VARS 0, 0 } } }, + [DELETE_ATTR] = { .nuops = 1, .uops = { { _DELETE_ATTR 0, 0 } } }, + [DELETE_DEREF] = { .nuops = 1, .uops = { { _DELETE_DEREF 0, 0 } } }, + [DELETE_FAST] = { .nuops = 1, .uops = { { _DELETE_FAST 0, 0 } } }, + [DELETE_GLOBAL] = { .nuops = 1, .uops = { { _DELETE_GLOBAL 0, 0 } } }, + [DELETE_NAME] = { .nuops = 1, .uops = { { _DELETE_NAME 0, 0 } } }, + [DELETE_SUBSCR] = { .nuops = 1, .uops = { { _DELETE_SUBSCR 0, 0 } } }, + [DICT_MERGE] = { .nuops = 1, .uops = { { _DICT_MERGE 0, 0 } } }, + [DICT_UPDATE] = { .nuops = 1, .uops = { { _DICT_UPDATE 0, 0 } } }, + [END_ASYNC_FOR] = { .nuops = 0, .uops = { } }, + [END_FOR] = { .nuops = 2, .uops = { { _POP_TOP 0, 0 }, { _POP_TOP 0, 0 } } }, + [END_SEND] = { .nuops = 1, .uops = { { _END_SEND 0, 0 } } }, + [ENTER_EXECUTOR] = { .nuops = 1, .uops = { { _ENTER_EXECUTOR 0, 0 } } }, + [EXIT_INIT_CHECK] = { .nuops = 1, .uops = { { _EXIT_INIT_CHECK 0, 0 } } }, + [EXTENDED_ARG] = { .nuops = 1, .uops = { { _EXTENDED_ARG 0, 0 } } }, + [FORMAT_SIMPLE] = { .nuops = 1, .uops = { { _FORMAT_SIMPLE 0, 0 } } }, + [FORMAT_WITH_SPEC] = { .nuops = 1, .uops = { { _FORMAT_WITH_SPEC 0, 0 } } }, + [FOR_ITER] = { .nuops = 0, .uops = { } }, + [FOR_ITER_GEN] = { .nuops = 0, .uops = { } }, + [FOR_ITER_LIST] = { .nuops = 0, .uops = { } }, + [FOR_ITER_RANGE] = { .nuops = 0, .uops = { } }, + [FOR_ITER_TUPLE] = { .nuops = 0, .uops = { } }, + [GET_AITER] = { .nuops = 1, .uops = { { _GET_AITER 0, 0 } } }, + [GET_ANEXT] = { .nuops = 1, .uops = { { _GET_ANEXT 0, 0 } } }, + [GET_AWAITABLE] = { .nuops = 1, .uops = { { _GET_AWAITABLE 0, 0 } } }, + [GET_ITER] = { .nuops = 1, .uops = { { _GET_ITER 0, 0 } } }, + [GET_LEN] = { .nuops = 1, .uops = { { _GET_LEN 0, 0 } } }, + [GET_YIELD_FROM_ITER] = { .nuops = 1, .uops = { { _GET_YIELD_FROM_ITER 0, 0 } } }, + [IMPORT_FROM] = { .nuops = 1, .uops = { { _IMPORT_FROM 0, 0 } } }, + [IMPORT_NAME] = { .nuops = 1, .uops = { { _IMPORT_NAME 0, 0 } } }, + [INSTRUMENTED_CALL] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_CALL_FUNCTION_EX] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_CALL_KW] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_END_FOR] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_END_SEND] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_FOR_ITER] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_INSTRUCTION] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_JUMP_BACKWARD] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_JUMP_FORWARD] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_LOAD_SUPER_ATTR] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_POP_JUMP_IF_NONE] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_RESUME] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_RETURN_CONST] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_RETURN_VALUE] = { .nuops = 0, .uops = { } }, + [INSTRUMENTED_YIELD_VALUE] = { .nuops = 0, .uops = { } }, + [INTERPRETER_EXIT] = { .nuops = 1, .uops = { { _INTERPRETER_EXIT 0, 0 } } }, + [IS_OP] = { .nuops = 1, .uops = { { _IS_OP 0, 0 } } }, + [JUMP_BACKWARD] = { .nuops = 0, .uops = { } }, + [JUMP_BACKWARD_NO_INTERRUPT] = { .nuops = 1, .uops = { { _JUMP_BACKWARD_NO_INTERRUPT 0, 0 } } }, + [JUMP_FORWARD] = { .nuops = 1, .uops = { { _JUMP_FORWARD 0, 0 } } }, + [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND 0, 0 } } }, + [LIST_EXTEND] = { .nuops = 1, .uops = { { _LIST_EXTEND 0, 0 } } }, + [LOAD_ASSERTION_ERROR] = { .nuops = 1, .uops = { { _LOAD_ASSERTION_ERROR 0, 0 } } }, + [LOAD_ATTR] = { .nuops = 0, .uops = { } }, + [LOAD_ATTR_CLASS] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _CHECK_ATTR_CLASS 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_CLASS 4, 5 } } }, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { .nuops = 0, .uops = { } }, + [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE 1, 3 }, { unused/5 5, 4 } } }, + [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT 0, 0 }, { unused/2 2, 3 }, { _LOAD_ATTR_METHOD_LAZY_DICT 4, 5 } } }, + [LOAD_ATTR_METHOD_NO_DICT] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_METHOD_NO_DICT 4, 5 } } }, + [LOAD_ATTR_METHOD_WITH_VALUES] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 0, 0 }, { _GUARD_KEYS_VERSION 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES 4, 5 } } }, + [LOAD_ATTR_MODULE] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _CHECK_ATTR_MODULE 2, 1 }, { _LOAD_ATTR_MODULE 1, 3 }, { unused/5 5, 4 } } }, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 4, 5 } } }, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 0, 0 }, { _GUARD_KEYS_VERSION 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 4, 5 } } }, + [LOAD_ATTR_PROPERTY] = { .nuops = 0, .uops = { } }, + [LOAD_ATTR_SLOT] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _LOAD_ATTR_SLOT 1, 3 }, { unused/5 5, 4 } } }, + [LOAD_ATTR_WITH_HINT] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_ATTR_WITH_HINT 0, 0 }, { _LOAD_ATTR_WITH_HINT 1, 3 }, { unused/5 5, 4 } } }, + [LOAD_BUILD_CLASS] = { .nuops = 1, .uops = { { _LOAD_BUILD_CLASS 0, 0 } } }, + [LOAD_CONST] = { .nuops = 1, .uops = { { _LOAD_CONST 0, 0 } } }, + [LOAD_DEREF] = { .nuops = 1, .uops = { { _LOAD_DEREF 0, 0 } } }, + [LOAD_FAST] = { .nuops = 1, .uops = { { _LOAD_FAST 0, 0 } } }, + [LOAD_FAST_AND_CLEAR] = { .nuops = 1, .uops = { { _LOAD_FAST_AND_CLEAR 0, 0 } } }, + [LOAD_FAST_CHECK] = { .nuops = 1, .uops = { { _LOAD_FAST_CHECK 0, 0 } } }, + [LOAD_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _LOAD_FAST 5, 0 }, { _LOAD_FAST 6, 0 } } }, + [LOAD_FROM_DICT_OR_DEREF] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF 0, 0 } } }, + [LOAD_FROM_DICT_OR_GLOBALS] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_GLOBALS 0, 0 } } }, + [LOAD_GLOBAL] = { .nuops = 0, .uops = { } }, + [LOAD_GLOBAL_BUILTIN] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_GLOBALS_VERSION 1, 1 }, { _GUARD_BUILTINS_VERSION 1, 2 }, { _LOAD_GLOBAL_BUILTINS 1, 3 } } }, + [LOAD_GLOBAL_MODULE] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_GLOBALS_VERSION 1, 1 }, { unused/1 1, 2 }, { _LOAD_GLOBAL_MODULE 1, 3 } } }, + [LOAD_LOCALS] = { .nuops = 1, .uops = { { _LOAD_LOCALS 0, 0 } } }, + [LOAD_NAME] = { .nuops = 1, .uops = { { _LOAD_NAME 0, 0 } } }, + [LOAD_SUPER_ATTR] = { .nuops = 0, .uops = { } }, + [LOAD_SUPER_ATTR_ATTR] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_ATTR 1, 0 } } }, + [LOAD_SUPER_ATTR_METHOD] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_METHOD 1, 0 } } }, + [MAKE_CELL] = { .nuops = 1, .uops = { { _MAKE_CELL 0, 0 } } }, + [MAKE_FUNCTION] = { .nuops = 1, .uops = { { _MAKE_FUNCTION 0, 0 } } }, + [MAP_ADD] = { .nuops = 1, .uops = { { _MAP_ADD 0, 0 } } }, + [MATCH_CLASS] = { .nuops = 1, .uops = { { _MATCH_CLASS 0, 0 } } }, + [MATCH_KEYS] = { .nuops = 1, .uops = { { _MATCH_KEYS 0, 0 } } }, + [MATCH_MAPPING] = { .nuops = 1, .uops = { { _MATCH_MAPPING 0, 0 } } }, + [MATCH_SEQUENCE] = { .nuops = 1, .uops = { { _MATCH_SEQUENCE 0, 0 } } }, + [NOP] = { .nuops = 1, .uops = { { _NOP 0, 0 } } }, + [POP_EXCEPT] = { .nuops = 1, .uops = { { _POP_EXCEPT 0, 0 } } }, + [POP_JUMP_IF_FALSE] = { .nuops = 0, .uops = { } }, + [POP_JUMP_IF_NONE] = { .nuops = 0, .uops = { } }, + [POP_JUMP_IF_NOT_NONE] = { .nuops = 0, .uops = { } }, + [POP_JUMP_IF_TRUE] = { .nuops = 0, .uops = { } }, + [POP_TOP] = { .nuops = 1, .uops = { { _POP_TOP 0, 0 } } }, + [PUSH_EXC_INFO] = { .nuops = 1, .uops = { { _PUSH_EXC_INFO 0, 0 } } }, + [PUSH_NULL] = { .nuops = 1, .uops = { { _PUSH_NULL 0, 0 } } }, + [RAISE_VARARGS] = { .nuops = 0, .uops = { } }, + [RERAISE] = { .nuops = 0, .uops = { } }, + [RESERVED] = { .nuops = 1, .uops = { { _RESERVED 0, 0 } } }, + [RESUME] = { .nuops = 0, .uops = { } }, + [RESUME_CHECK] = { .nuops = 1, .uops = { { _RESUME_CHECK 0, 0 } } }, + [RETURN_CONST] = { .nuops = 2, .uops = { { _LOAD_CONST 0, 0 }, { _POP_FRAME 0, 0 } } }, + [RETURN_GENERATOR] = { .nuops = 1, .uops = { { _RETURN_GENERATOR 0, 0 } } }, + [RETURN_VALUE] = { .nuops = 1, .uops = { { _POP_FRAME 0, 0 } } }, + [SEND] = { .nuops = 0, .uops = { } }, + [SEND_GEN] = { .nuops = 0, .uops = { } }, + [SETUP_ANNOTATIONS] = { .nuops = 1, .uops = { { _SETUP_ANNOTATIONS 0, 0 } } }, + [SET_ADD] = { .nuops = 1, .uops = { { _SET_ADD 0, 0 } } }, + [SET_FUNCTION_ATTRIBUTE] = { .nuops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE 0, 0 } } }, + [SET_UPDATE] = { .nuops = 1, .uops = { { _SET_UPDATE 0, 0 } } }, + [STORE_ATTR] = { .nuops = 0, .uops = { } }, + [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE 1, 3 } } }, + [STORE_ATTR_SLOT] = { .nuops = 3, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _STORE_ATTR_SLOT 1, 3 } } }, + [STORE_ATTR_WITH_HINT] = { .nuops = 0, .uops = { } }, + [STORE_DEREF] = { .nuops = 1, .uops = { { _STORE_DEREF 0, 0 } } }, + [STORE_FAST] = { .nuops = 1, .uops = { { _STORE_FAST 0, 0 } } }, + [STORE_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _STORE_FAST 5, 0 }, { _LOAD_FAST 6, 0 } } }, + [STORE_FAST_STORE_FAST] = { .nuops = 2, .uops = { { _STORE_FAST 5, 0 }, { _STORE_FAST 6, 0 } } }, + [STORE_GLOBAL] = { .nuops = 1, .uops = { { _STORE_GLOBAL 0, 0 } } }, + [STORE_NAME] = { .nuops = 1, .uops = { { _STORE_NAME 0, 0 } } }, + [STORE_SLICE] = { .nuops = 1, .uops = { { _STORE_SLICE 0, 0 } } }, + [STORE_SUBSCR] = { .nuops = 0, .uops = { } }, + [STORE_SUBSCR_DICT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_DICT 1, 0 } } }, + [STORE_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_LIST_INT 1, 0 } } }, + [SWAP] = { .nuops = 1, .uops = { { _SWAP 0, 0 } } }, + [TO_BOOL] = { .nuops = 0, .uops = { } }, + [TO_BOOL_ALWAYS_TRUE] = { .nuops = 1, .uops = { { _TO_BOOL_ALWAYS_TRUE 3, 0 } } }, + [TO_BOOL_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL_BOOL 3, 0 } } }, + [TO_BOOL_INT] = { .nuops = 1, .uops = { { _TO_BOOL_INT 3, 0 } } }, + [TO_BOOL_LIST] = { .nuops = 1, .uops = { { _TO_BOOL_LIST 3, 0 } } }, + [TO_BOOL_NONE] = { .nuops = 1, .uops = { { _TO_BOOL_NONE 3, 0 } } }, + [TO_BOOL_STR] = { .nuops = 1, .uops = { { _TO_BOOL_STR 3, 0 } } }, + [UNARY_INVERT] = { .nuops = 1, .uops = { { _UNARY_INVERT 0, 0 } } }, + [UNARY_NEGATIVE] = { .nuops = 1, .uops = { { _UNARY_NEGATIVE 0, 0 } } }, + [UNARY_NOT] = { .nuops = 1, .uops = { { _UNARY_NOT 0, 0 } } }, + [UNPACK_EX] = { .nuops = 1, .uops = { { _UNPACK_EX 0, 0 } } }, + [UNPACK_SEQUENCE] = { .nuops = 0, .uops = { } }, + [UNPACK_SEQUENCE_LIST] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_LIST 1, 0 } } }, + [UNPACK_SEQUENCE_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TUPLE 1, 0 } } }, + [UNPACK_SEQUENCE_TWO_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TWO_TUPLE 1, 0 } } }, + [WITH_EXCEPT_START] = { .nuops = 1, .uops = { { _WITH_EXCEPT_START 0, 0 } } }, + [YIELD_VALUE] = { .nuops = 1, .uops = { { _YIELD_VALUE 0, 0 } } }, }; #endif // NEED_OPCODE_METADATA diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 710990abd39298..cc103c4f8a6e02 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -186,7 +186,7 @@ def generate_expansion_table( out.emit("_PyOpcode_macro_expansion[256] = {\n") for inst_name, expansions in expansions_table.items(): uops = [f"{{ {name} {size}, {offset} }}" for (name, size, offset) in expansions] - out.emit(f"[{inst_name}] = {{ .nops = {len(expansions)}, .uops = {{ {", ".join(uops)} }}}},\n") + out.emit(f"[{inst_name}] = {{ .nuops = {len(expansions)}, .uops = {{ {", ".join(uops)} }} }},\n") out.emit("};\n") out.emit("#endif // NEED_OPCODE_METADATA\n\n") From 1c51db3cbfd9b907a7cdf11afd05c49460e9040e Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 03:06:48 +0000 Subject: [PATCH 10/51] Reorganise a bit to reduce output diff --- Tools/cases_generator/analyzer.py | 10 +++++----- Tools/cases_generator/generators_common.py | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index db615933a4b129..b049df7f7be9f4 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -327,10 +327,10 @@ def always_exits(op: parser.InstDef) -> bool: def compute_properties(op: parser.InstDef) -> Properties: has_free = ( - variable_used(op, "PyCell_New") - or variable_used(op, "PyCell_GET") - or variable_used(op, "PyCell_SET") - ) + variable_used(op, "PyCell_New") + or variable_used(op, "PyCell_GET") + or variable_used(op, "PyCell_SET") + ) return Properties( escapes=makes_escaping_api_call(op), infallible=is_infallible(op), @@ -344,7 +344,7 @@ def compute_properties(op: parser.InstDef) -> Properties: tier_one_only=variable_used(op, "TIER_ONE_ONLY"), uses_co_consts=variable_used(op, "FRAME_CO_CONSTS"), uses_co_names=variable_used(op, "FRAME_CO_NAMES"), - uses_locals= not has_free and (variable_used(op, "GETLOCAL") or variable_used(op, "SETLOCAL")), + uses_locals= (variable_used(op, "GETLOCAL") or variable_used(op, "SETLOCAL")) and not has_free, has_free=has_free, ) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index de80fe02ac8571..54171407edd4a4 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -198,7 +198,7 @@ def cflags(p: Properties) -> str: flags.append("HAS_JUMP_FLAG") if p.has_free: flags.append("HAS_FREE_FLAG") - elif p.uses_locals: + if p.uses_locals: flags.append("HAS_LOCAL_FLAG") if p.deopts: flags.append("HAS_DEOPT_FLAG") From f38d34b17764155812636221daf4894637751ebb Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 03:16:59 +0000 Subject: [PATCH 11/51] Reorganise a bit to reduce output diff --- Include/internal/pycore_opcode_metadata.h | 306 +++++++++--------- .../opcode_metadata_generator.py | 4 +- 2 files changed, 155 insertions(+), 155 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index c59628876b1200..3385415023a26a 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -295,95 +295,95 @@ _PyOpcode_macro_expansion[256]; #ifdef NEED_OPCODE_METADATA const struct opcode_macro_expansion _PyOpcode_macro_expansion[256] = { - [BEFORE_ASYNC_WITH] = { .nuops = 1, .uops = { { _BEFORE_ASYNC_WITH 0, 0 } } }, - [BEFORE_WITH] = { .nuops = 1, .uops = { { _BEFORE_WITH 0, 0 } } }, + [BEFORE_ASYNC_WITH] = { .nuops = 1, .uops = { { _BEFORE_ASYNC_WITH, 0, 0 } } }, + [BEFORE_WITH] = { .nuops = 1, .uops = { { _BEFORE_WITH, 0, 0 } } }, [BINARY_OP] = { .nuops = 0, .uops = { } }, - [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_ADD_FLOAT 1, 0 } } }, - [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_ADD_INT 1, 0 } } }, - [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE 0, 0 }, { _BINARY_OP_ADD_UNICODE 1, 0 } } }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE 1, 0 } } }, - [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT 1, 0 } } }, - [BINARY_OP_MULTIPLY_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_MULTIPLY_INT 1, 0 } } }, - [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT 1, 0 } } }, - [BINARY_OP_SUBTRACT_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT 0, 0 }, { _BINARY_OP_SUBTRACT_INT 1, 0 } } }, - [BINARY_SLICE] = { .nuops = 1, .uops = { { _BINARY_SLICE 0, 0 } } }, + [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_ADD_FLOAT, 1, 0 } } }, + [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_ADD_INT, 1, 0 } } }, + [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_ADD_UNICODE, 1, 0 } } }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE, 1, 0 } } }, + [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT, 1, 0 } } }, + [BINARY_OP_MULTIPLY_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_MULTIPLY_INT, 1, 0 } } }, + [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, 1, 0 } } }, + [BINARY_OP_SUBTRACT_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_SUBTRACT_INT, 1, 0 } } }, + [BINARY_SLICE] = { .nuops = 1, .uops = { { _BINARY_SLICE, 0, 0 } } }, [BINARY_SUBSCR] = { .nuops = 0, .uops = { } }, - [BINARY_SUBSCR_DICT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_DICT 1, 0 } } }, + [BINARY_SUBSCR_DICT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_DICT, 1, 0 } } }, [BINARY_SUBSCR_GETITEM] = { .nuops = 0, .uops = { } }, - [BINARY_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT 1, 0 } } }, - [BINARY_SUBSCR_STR_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_STR_INT 1, 0 } } }, - [BINARY_SUBSCR_TUPLE_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_TUPLE_INT 1, 0 } } }, - [BUILD_CONST_KEY_MAP] = { .nuops = 1, .uops = { { _BUILD_CONST_KEY_MAP 0, 0 } } }, - [BUILD_LIST] = { .nuops = 1, .uops = { { _BUILD_LIST 0, 0 } } }, - [BUILD_MAP] = { .nuops = 1, .uops = { { _BUILD_MAP 0, 0 } } }, - [BUILD_SET] = { .nuops = 1, .uops = { { _BUILD_SET 0, 0 } } }, - [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE 0, 0 } } }, - [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING 0, 0 } } }, - [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE 0, 0 } } }, - [CACHE] = { .nuops = 1, .uops = { { _CACHE 0, 0 } } }, + [BINARY_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT, 1, 0 } } }, + [BINARY_SUBSCR_STR_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_STR_INT, 1, 0 } } }, + [BINARY_SUBSCR_TUPLE_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_TUPLE_INT, 1, 0 } } }, + [BUILD_CONST_KEY_MAP] = { .nuops = 1, .uops = { { _BUILD_CONST_KEY_MAP, 0, 0 } } }, + [BUILD_LIST] = { .nuops = 1, .uops = { { _BUILD_LIST, 0, 0 } } }, + [BUILD_MAP] = { .nuops = 1, .uops = { { _BUILD_MAP, 0, 0 } } }, + [BUILD_SET] = { .nuops = 1, .uops = { { _BUILD_SET, 0, 0 } } }, + [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE, 0, 0 } } }, + [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING, 0, 0 } } }, + [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE, 0, 0 } } }, + [CACHE] = { .nuops = 1, .uops = { { _CACHE, 0, 0 } } }, [CALL] = { .nuops = 0, .uops = { } }, [CALL_ALLOC_AND_ENTER_INIT] = { .nuops = 0, .uops = { } }, - [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 9, .uops = { { unused/1 1, 0 }, { _CHECK_PEP_523 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS 2, 1 }, { _CHECK_STACK_SPACE 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS 0, 0 }, { _SAVE_RETURN_OFFSET 7, 3 }, { _PUSH_FRAME 0, 0 } } }, - [CALL_BUILTIN_CLASS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_CLASS 3, 0 } } }, - [CALL_BUILTIN_FAST] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST 3, 0 } } }, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST_WITH_KEYWORDS 3, 0 } } }, - [CALL_BUILTIN_O] = { .nuops = 1, .uops = { { _CALL_BUILTIN_O 3, 0 } } }, + [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 9, .uops = { { unused/1, 1, 0 }, { _CHECK_PEP_523, 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, + [CALL_BUILTIN_CLASS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_CLASS, 3, 0 } } }, + [CALL_BUILTIN_FAST] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST, 3, 0 } } }, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST_WITH_KEYWORDS, 3, 0 } } }, + [CALL_BUILTIN_O] = { .nuops = 1, .uops = { { _CALL_BUILTIN_O, 3, 0 } } }, [CALL_FUNCTION_EX] = { .nuops = 0, .uops = { } }, - [CALL_INTRINSIC_1] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_1 0, 0 } } }, - [CALL_INTRINSIC_2] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_2 0, 0 } } }, - [CALL_ISINSTANCE] = { .nuops = 1, .uops = { { _CALL_ISINSTANCE 3, 0 } } }, + [CALL_INTRINSIC_1] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_1, 0, 0 } } }, + [CALL_INTRINSIC_2] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_2, 0, 0 } } }, + [CALL_ISINSTANCE] = { .nuops = 1, .uops = { { _CALL_ISINSTANCE, 3, 0 } } }, [CALL_KW] = { .nuops = 0, .uops = { } }, - [CALL_LEN] = { .nuops = 1, .uops = { { _CALL_LEN 3, 0 } } }, - [CALL_LIST_APPEND] = { .nuops = 1, .uops = { { _CALL_LIST_APPEND 3, 0 } } }, - [CALL_METHOD_DESCRIPTOR_FAST] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST 3, 0 } } }, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 3, 0 } } }, - [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_NOARGS 3, 0 } } }, - [CALL_METHOD_DESCRIPTOR_O] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_O 3, 0 } } }, - [CALL_PY_EXACT_ARGS] = { .nuops = 7, .uops = { { unused/1 1, 0 }, { _CHECK_PEP_523 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS 2, 1 }, { _CHECK_STACK_SPACE 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS 0, 0 }, { _SAVE_RETURN_OFFSET 7, 3 }, { _PUSH_FRAME 0, 0 } } }, + [CALL_LEN] = { .nuops = 1, .uops = { { _CALL_LEN, 3, 0 } } }, + [CALL_LIST_APPEND] = { .nuops = 1, .uops = { { _CALL_LIST_APPEND, 3, 0 } } }, + [CALL_METHOD_DESCRIPTOR_FAST] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST, 3, 0 } } }, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, 3, 0 } } }, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_NOARGS, 3, 0 } } }, + [CALL_METHOD_DESCRIPTOR_O] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_O, 3, 0 } } }, + [CALL_PY_EXACT_ARGS] = { .nuops = 7, .uops = { { unused/1, 1, 0 }, { _CHECK_PEP_523, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, [CALL_PY_WITH_DEFAULTS] = { .nuops = 0, .uops = { } }, - [CALL_STR_1] = { .nuops = 1, .uops = { { _CALL_STR_1 3, 0 } } }, - [CALL_TUPLE_1] = { .nuops = 1, .uops = { { _CALL_TUPLE_1 3, 0 } } }, - [CALL_TYPE_1] = { .nuops = 1, .uops = { { _CALL_TYPE_1 3, 0 } } }, - [CHECK_EG_MATCH] = { .nuops = 1, .uops = { { _CHECK_EG_MATCH 0, 0 } } }, - [CHECK_EXC_MATCH] = { .nuops = 1, .uops = { { _CHECK_EXC_MATCH 0, 0 } } }, + [CALL_STR_1] = { .nuops = 1, .uops = { { _CALL_STR_1, 3, 0 } } }, + [CALL_TUPLE_1] = { .nuops = 1, .uops = { { _CALL_TUPLE_1, 3, 0 } } }, + [CALL_TYPE_1] = { .nuops = 1, .uops = { { _CALL_TYPE_1, 3, 0 } } }, + [CHECK_EG_MATCH] = { .nuops = 1, .uops = { { _CHECK_EG_MATCH, 0, 0 } } }, + [CHECK_EXC_MATCH] = { .nuops = 1, .uops = { { _CHECK_EXC_MATCH, 0, 0 } } }, [CLEANUP_THROW] = { .nuops = 0, .uops = { } }, [COMPARE_OP] = { .nuops = 0, .uops = { } }, - [COMPARE_OP_FLOAT] = { .nuops = 1, .uops = { { _COMPARE_OP_FLOAT 1, 0 } } }, - [COMPARE_OP_INT] = { .nuops = 1, .uops = { { _COMPARE_OP_INT 1, 0 } } }, - [COMPARE_OP_STR] = { .nuops = 1, .uops = { { _COMPARE_OP_STR 1, 0 } } }, - [CONTAINS_OP] = { .nuops = 1, .uops = { { _CONTAINS_OP 0, 0 } } }, - [CONVERT_VALUE] = { .nuops = 1, .uops = { { _CONVERT_VALUE 0, 0 } } }, - [COPY] = { .nuops = 1, .uops = { { _COPY 0, 0 } } }, - [COPY_FREE_VARS] = { .nuops = 1, .uops = { { _COPY_FREE_VARS 0, 0 } } }, - [DELETE_ATTR] = { .nuops = 1, .uops = { { _DELETE_ATTR 0, 0 } } }, - [DELETE_DEREF] = { .nuops = 1, .uops = { { _DELETE_DEREF 0, 0 } } }, - [DELETE_FAST] = { .nuops = 1, .uops = { { _DELETE_FAST 0, 0 } } }, - [DELETE_GLOBAL] = { .nuops = 1, .uops = { { _DELETE_GLOBAL 0, 0 } } }, - [DELETE_NAME] = { .nuops = 1, .uops = { { _DELETE_NAME 0, 0 } } }, - [DELETE_SUBSCR] = { .nuops = 1, .uops = { { _DELETE_SUBSCR 0, 0 } } }, - [DICT_MERGE] = { .nuops = 1, .uops = { { _DICT_MERGE 0, 0 } } }, - [DICT_UPDATE] = { .nuops = 1, .uops = { { _DICT_UPDATE 0, 0 } } }, + [COMPARE_OP_FLOAT] = { .nuops = 1, .uops = { { _COMPARE_OP_FLOAT, 1, 0 } } }, + [COMPARE_OP_INT] = { .nuops = 1, .uops = { { _COMPARE_OP_INT, 1, 0 } } }, + [COMPARE_OP_STR] = { .nuops = 1, .uops = { { _COMPARE_OP_STR, 1, 0 } } }, + [CONTAINS_OP] = { .nuops = 1, .uops = { { _CONTAINS_OP, 0, 0 } } }, + [CONVERT_VALUE] = { .nuops = 1, .uops = { { _CONVERT_VALUE, 0, 0 } } }, + [COPY] = { .nuops = 1, .uops = { { _COPY, 0, 0 } } }, + [COPY_FREE_VARS] = { .nuops = 1, .uops = { { _COPY_FREE_VARS, 0, 0 } } }, + [DELETE_ATTR] = { .nuops = 1, .uops = { { _DELETE_ATTR, 0, 0 } } }, + [DELETE_DEREF] = { .nuops = 1, .uops = { { _DELETE_DEREF, 0, 0 } } }, + [DELETE_FAST] = { .nuops = 1, .uops = { { _DELETE_FAST, 0, 0 } } }, + [DELETE_GLOBAL] = { .nuops = 1, .uops = { { _DELETE_GLOBAL, 0, 0 } } }, + [DELETE_NAME] = { .nuops = 1, .uops = { { _DELETE_NAME, 0, 0 } } }, + [DELETE_SUBSCR] = { .nuops = 1, .uops = { { _DELETE_SUBSCR, 0, 0 } } }, + [DICT_MERGE] = { .nuops = 1, .uops = { { _DICT_MERGE, 0, 0 } } }, + [DICT_UPDATE] = { .nuops = 1, .uops = { { _DICT_UPDATE, 0, 0 } } }, [END_ASYNC_FOR] = { .nuops = 0, .uops = { } }, - [END_FOR] = { .nuops = 2, .uops = { { _POP_TOP 0, 0 }, { _POP_TOP 0, 0 } } }, - [END_SEND] = { .nuops = 1, .uops = { { _END_SEND 0, 0 } } }, - [ENTER_EXECUTOR] = { .nuops = 1, .uops = { { _ENTER_EXECUTOR 0, 0 } } }, - [EXIT_INIT_CHECK] = { .nuops = 1, .uops = { { _EXIT_INIT_CHECK 0, 0 } } }, - [EXTENDED_ARG] = { .nuops = 1, .uops = { { _EXTENDED_ARG 0, 0 } } }, - [FORMAT_SIMPLE] = { .nuops = 1, .uops = { { _FORMAT_SIMPLE 0, 0 } } }, - [FORMAT_WITH_SPEC] = { .nuops = 1, .uops = { { _FORMAT_WITH_SPEC 0, 0 } } }, + [END_FOR] = { .nuops = 2, .uops = { { _POP_TOP, 0, 0 }, { _POP_TOP, 0, 0 } } }, + [END_SEND] = { .nuops = 1, .uops = { { _END_SEND, 0, 0 } } }, + [ENTER_EXECUTOR] = { .nuops = 1, .uops = { { _ENTER_EXECUTOR, 0, 0 } } }, + [EXIT_INIT_CHECK] = { .nuops = 1, .uops = { { _EXIT_INIT_CHECK, 0, 0 } } }, + [EXTENDED_ARG] = { .nuops = 1, .uops = { { _EXTENDED_ARG, 0, 0 } } }, + [FORMAT_SIMPLE] = { .nuops = 1, .uops = { { _FORMAT_SIMPLE, 0, 0 } } }, + [FORMAT_WITH_SPEC] = { .nuops = 1, .uops = { { _FORMAT_WITH_SPEC, 0, 0 } } }, [FOR_ITER] = { .nuops = 0, .uops = { } }, [FOR_ITER_GEN] = { .nuops = 0, .uops = { } }, [FOR_ITER_LIST] = { .nuops = 0, .uops = { } }, [FOR_ITER_RANGE] = { .nuops = 0, .uops = { } }, [FOR_ITER_TUPLE] = { .nuops = 0, .uops = { } }, - [GET_AITER] = { .nuops = 1, .uops = { { _GET_AITER 0, 0 } } }, - [GET_ANEXT] = { .nuops = 1, .uops = { { _GET_ANEXT 0, 0 } } }, - [GET_AWAITABLE] = { .nuops = 1, .uops = { { _GET_AWAITABLE 0, 0 } } }, - [GET_ITER] = { .nuops = 1, .uops = { { _GET_ITER 0, 0 } } }, - [GET_LEN] = { .nuops = 1, .uops = { { _GET_LEN 0, 0 } } }, - [GET_YIELD_FROM_ITER] = { .nuops = 1, .uops = { { _GET_YIELD_FROM_ITER 0, 0 } } }, - [IMPORT_FROM] = { .nuops = 1, .uops = { { _IMPORT_FROM 0, 0 } } }, - [IMPORT_NAME] = { .nuops = 1, .uops = { { _IMPORT_NAME 0, 0 } } }, + [GET_AITER] = { .nuops = 1, .uops = { { _GET_AITER, 0, 0 } } }, + [GET_ANEXT] = { .nuops = 1, .uops = { { _GET_ANEXT, 0, 0 } } }, + [GET_AWAITABLE] = { .nuops = 1, .uops = { { _GET_AWAITABLE, 0, 0 } } }, + [GET_ITER] = { .nuops = 1, .uops = { { _GET_ITER, 0, 0 } } }, + [GET_LEN] = { .nuops = 1, .uops = { { _GET_LEN, 0, 0 } } }, + [GET_YIELD_FROM_ITER] = { .nuops = 1, .uops = { { _GET_YIELD_FROM_ITER, 0, 0 } } }, + [IMPORT_FROM] = { .nuops = 1, .uops = { { _IMPORT_FROM, 0, 0 } } }, + [IMPORT_NAME] = { .nuops = 1, .uops = { { _IMPORT_NAME, 0, 0 } } }, [INSTRUMENTED_CALL] = { .nuops = 0, .uops = { } }, [INSTRUMENTED_CALL_FUNCTION_EX] = { .nuops = 0, .uops = { } }, [INSTRUMENTED_CALL_KW] = { .nuops = 0, .uops = { } }, @@ -402,106 +402,106 @@ _PyOpcode_macro_expansion[256] = { [INSTRUMENTED_RETURN_CONST] = { .nuops = 0, .uops = { } }, [INSTRUMENTED_RETURN_VALUE] = { .nuops = 0, .uops = { } }, [INSTRUMENTED_YIELD_VALUE] = { .nuops = 0, .uops = { } }, - [INTERPRETER_EXIT] = { .nuops = 1, .uops = { { _INTERPRETER_EXIT 0, 0 } } }, - [IS_OP] = { .nuops = 1, .uops = { { _IS_OP 0, 0 } } }, + [INTERPRETER_EXIT] = { .nuops = 1, .uops = { { _INTERPRETER_EXIT, 0, 0 } } }, + [IS_OP] = { .nuops = 1, .uops = { { _IS_OP, 0, 0 } } }, [JUMP_BACKWARD] = { .nuops = 0, .uops = { } }, - [JUMP_BACKWARD_NO_INTERRUPT] = { .nuops = 1, .uops = { { _JUMP_BACKWARD_NO_INTERRUPT 0, 0 } } }, - [JUMP_FORWARD] = { .nuops = 1, .uops = { { _JUMP_FORWARD 0, 0 } } }, - [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND 0, 0 } } }, - [LIST_EXTEND] = { .nuops = 1, .uops = { { _LIST_EXTEND 0, 0 } } }, - [LOAD_ASSERTION_ERROR] = { .nuops = 1, .uops = { { _LOAD_ASSERTION_ERROR 0, 0 } } }, + [JUMP_BACKWARD_NO_INTERRUPT] = { .nuops = 1, .uops = { { _JUMP_BACKWARD_NO_INTERRUPT, 0, 0 } } }, + [JUMP_FORWARD] = { .nuops = 1, .uops = { { _JUMP_FORWARD, 0, 0 } } }, + [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND, 0, 0 } } }, + [LIST_EXTEND] = { .nuops = 1, .uops = { { _LIST_EXTEND, 0, 0 } } }, + [LOAD_ASSERTION_ERROR] = { .nuops = 1, .uops = { { _LOAD_ASSERTION_ERROR, 0, 0 } } }, [LOAD_ATTR] = { .nuops = 0, .uops = { } }, - [LOAD_ATTR_CLASS] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _CHECK_ATTR_CLASS 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_CLASS 4, 5 } } }, + [LOAD_ATTR_CLASS] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _CHECK_ATTR_CLASS, 2, 1 }, { unused/2, 2, 3 }, { _LOAD_ATTR_CLASS, 4, 5 } } }, [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { .nuops = 0, .uops = { } }, - [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE 1, 3 }, { unused/5 5, 4 } } }, - [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT 0, 0 }, { unused/2 2, 3 }, { _LOAD_ATTR_METHOD_LAZY_DICT 4, 5 } } }, - [LOAD_ATTR_METHOD_NO_DICT] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_METHOD_NO_DICT 4, 5 } } }, - [LOAD_ATTR_METHOD_WITH_VALUES] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 0, 0 }, { _GUARD_KEYS_VERSION 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES 4, 5 } } }, - [LOAD_ATTR_MODULE] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _CHECK_ATTR_MODULE 2, 1 }, { _LOAD_ATTR_MODULE 1, 3 }, { unused/5 5, 4 } } }, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { unused/2 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 4, 5 } } }, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 0, 0 }, { _GUARD_KEYS_VERSION 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 4, 5 } } }, + [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES, 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE, 1, 3 }, { unused/5, 5, 4 } } }, + [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT, 0, 0 }, { unused/2, 2, 3 }, { _LOAD_ATTR_METHOD_LAZY_DICT, 4, 5 } } }, + [LOAD_ATTR_METHOD_NO_DICT] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { unused/2, 2, 3 }, { _LOAD_ATTR_METHOD_NO_DICT, 4, 5 } } }, + [LOAD_ATTR_METHOD_WITH_VALUES] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, 0, 0 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES, 4, 5 } } }, + [LOAD_ATTR_MODULE] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _CHECK_ATTR_MODULE, 2, 1 }, { _LOAD_ATTR_MODULE, 1, 3 }, { unused/5, 5, 4 } } }, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { unused/2, 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT, 4, 5 } } }, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, 0, 0 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES, 4, 5 } } }, [LOAD_ATTR_PROPERTY] = { .nuops = 0, .uops = { } }, - [LOAD_ATTR_SLOT] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _LOAD_ATTR_SLOT 1, 3 }, { unused/5 5, 4 } } }, - [LOAD_ATTR_WITH_HINT] = { .nuops = 5, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _CHECK_ATTR_WITH_HINT 0, 0 }, { _LOAD_ATTR_WITH_HINT 1, 3 }, { unused/5 5, 4 } } }, - [LOAD_BUILD_CLASS] = { .nuops = 1, .uops = { { _LOAD_BUILD_CLASS 0, 0 } } }, - [LOAD_CONST] = { .nuops = 1, .uops = { { _LOAD_CONST 0, 0 } } }, - [LOAD_DEREF] = { .nuops = 1, .uops = { { _LOAD_DEREF 0, 0 } } }, - [LOAD_FAST] = { .nuops = 1, .uops = { { _LOAD_FAST 0, 0 } } }, - [LOAD_FAST_AND_CLEAR] = { .nuops = 1, .uops = { { _LOAD_FAST_AND_CLEAR 0, 0 } } }, - [LOAD_FAST_CHECK] = { .nuops = 1, .uops = { { _LOAD_FAST_CHECK 0, 0 } } }, - [LOAD_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _LOAD_FAST 5, 0 }, { _LOAD_FAST 6, 0 } } }, - [LOAD_FROM_DICT_OR_DEREF] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF 0, 0 } } }, - [LOAD_FROM_DICT_OR_GLOBALS] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_GLOBALS 0, 0 } } }, + [LOAD_ATTR_SLOT] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_SLOT, 1, 3 }, { unused/5, 5, 4 } } }, + [LOAD_ATTR_WITH_HINT] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_WITH_HINT, 0, 0 }, { _LOAD_ATTR_WITH_HINT, 1, 3 }, { unused/5, 5, 4 } } }, + [LOAD_BUILD_CLASS] = { .nuops = 1, .uops = { { _LOAD_BUILD_CLASS, 0, 0 } } }, + [LOAD_CONST] = { .nuops = 1, .uops = { { _LOAD_CONST, 0, 0 } } }, + [LOAD_DEREF] = { .nuops = 1, .uops = { { _LOAD_DEREF, 0, 0 } } }, + [LOAD_FAST] = { .nuops = 1, .uops = { { _LOAD_FAST, 0, 0 } } }, + [LOAD_FAST_AND_CLEAR] = { .nuops = 1, .uops = { { _LOAD_FAST_AND_CLEAR, 0, 0 } } }, + [LOAD_FAST_CHECK] = { .nuops = 1, .uops = { { _LOAD_FAST_CHECK, 0, 0 } } }, + [LOAD_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _LOAD_FAST, 5, 0 }, { _LOAD_FAST, 6, 0 } } }, + [LOAD_FROM_DICT_OR_DEREF] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF, 0, 0 } } }, + [LOAD_FROM_DICT_OR_GLOBALS] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_GLOBALS, 0, 0 } } }, [LOAD_GLOBAL] = { .nuops = 0, .uops = { } }, - [LOAD_GLOBAL_BUILTIN] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_GLOBALS_VERSION 1, 1 }, { _GUARD_BUILTINS_VERSION 1, 2 }, { _LOAD_GLOBAL_BUILTINS 1, 3 } } }, - [LOAD_GLOBAL_MODULE] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_GLOBALS_VERSION 1, 1 }, { unused/1 1, 2 }, { _LOAD_GLOBAL_MODULE 1, 3 } } }, - [LOAD_LOCALS] = { .nuops = 1, .uops = { { _LOAD_LOCALS 0, 0 } } }, - [LOAD_NAME] = { .nuops = 1, .uops = { { _LOAD_NAME 0, 0 } } }, + [LOAD_GLOBAL_BUILTIN] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_GLOBALS_VERSION, 1, 1 }, { _GUARD_BUILTINS_VERSION, 1, 2 }, { _LOAD_GLOBAL_BUILTINS, 1, 3 } } }, + [LOAD_GLOBAL_MODULE] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_GLOBALS_VERSION, 1, 1 }, { unused/1, 1, 2 }, { _LOAD_GLOBAL_MODULE, 1, 3 } } }, + [LOAD_LOCALS] = { .nuops = 1, .uops = { { _LOAD_LOCALS, 0, 0 } } }, + [LOAD_NAME] = { .nuops = 1, .uops = { { _LOAD_NAME, 0, 0 } } }, [LOAD_SUPER_ATTR] = { .nuops = 0, .uops = { } }, - [LOAD_SUPER_ATTR_ATTR] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_ATTR 1, 0 } } }, - [LOAD_SUPER_ATTR_METHOD] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_METHOD 1, 0 } } }, - [MAKE_CELL] = { .nuops = 1, .uops = { { _MAKE_CELL 0, 0 } } }, - [MAKE_FUNCTION] = { .nuops = 1, .uops = { { _MAKE_FUNCTION 0, 0 } } }, - [MAP_ADD] = { .nuops = 1, .uops = { { _MAP_ADD 0, 0 } } }, - [MATCH_CLASS] = { .nuops = 1, .uops = { { _MATCH_CLASS 0, 0 } } }, - [MATCH_KEYS] = { .nuops = 1, .uops = { { _MATCH_KEYS 0, 0 } } }, - [MATCH_MAPPING] = { .nuops = 1, .uops = { { _MATCH_MAPPING 0, 0 } } }, - [MATCH_SEQUENCE] = { .nuops = 1, .uops = { { _MATCH_SEQUENCE 0, 0 } } }, - [NOP] = { .nuops = 1, .uops = { { _NOP 0, 0 } } }, - [POP_EXCEPT] = { .nuops = 1, .uops = { { _POP_EXCEPT 0, 0 } } }, + [LOAD_SUPER_ATTR_ATTR] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_ATTR, 1, 0 } } }, + [LOAD_SUPER_ATTR_METHOD] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_METHOD, 1, 0 } } }, + [MAKE_CELL] = { .nuops = 1, .uops = { { _MAKE_CELL, 0, 0 } } }, + [MAKE_FUNCTION] = { .nuops = 1, .uops = { { _MAKE_FUNCTION, 0, 0 } } }, + [MAP_ADD] = { .nuops = 1, .uops = { { _MAP_ADD, 0, 0 } } }, + [MATCH_CLASS] = { .nuops = 1, .uops = { { _MATCH_CLASS, 0, 0 } } }, + [MATCH_KEYS] = { .nuops = 1, .uops = { { _MATCH_KEYS, 0, 0 } } }, + [MATCH_MAPPING] = { .nuops = 1, .uops = { { _MATCH_MAPPING, 0, 0 } } }, + [MATCH_SEQUENCE] = { .nuops = 1, .uops = { { _MATCH_SEQUENCE, 0, 0 } } }, + [NOP] = { .nuops = 1, .uops = { { _NOP, 0, 0 } } }, + [POP_EXCEPT] = { .nuops = 1, .uops = { { _POP_EXCEPT, 0, 0 } } }, [POP_JUMP_IF_FALSE] = { .nuops = 0, .uops = { } }, [POP_JUMP_IF_NONE] = { .nuops = 0, .uops = { } }, [POP_JUMP_IF_NOT_NONE] = { .nuops = 0, .uops = { } }, [POP_JUMP_IF_TRUE] = { .nuops = 0, .uops = { } }, - [POP_TOP] = { .nuops = 1, .uops = { { _POP_TOP 0, 0 } } }, - [PUSH_EXC_INFO] = { .nuops = 1, .uops = { { _PUSH_EXC_INFO 0, 0 } } }, - [PUSH_NULL] = { .nuops = 1, .uops = { { _PUSH_NULL 0, 0 } } }, + [POP_TOP] = { .nuops = 1, .uops = { { _POP_TOP, 0, 0 } } }, + [PUSH_EXC_INFO] = { .nuops = 1, .uops = { { _PUSH_EXC_INFO, 0, 0 } } }, + [PUSH_NULL] = { .nuops = 1, .uops = { { _PUSH_NULL, 0, 0 } } }, [RAISE_VARARGS] = { .nuops = 0, .uops = { } }, [RERAISE] = { .nuops = 0, .uops = { } }, - [RESERVED] = { .nuops = 1, .uops = { { _RESERVED 0, 0 } } }, + [RESERVED] = { .nuops = 1, .uops = { { _RESERVED, 0, 0 } } }, [RESUME] = { .nuops = 0, .uops = { } }, - [RESUME_CHECK] = { .nuops = 1, .uops = { { _RESUME_CHECK 0, 0 } } }, - [RETURN_CONST] = { .nuops = 2, .uops = { { _LOAD_CONST 0, 0 }, { _POP_FRAME 0, 0 } } }, - [RETURN_GENERATOR] = { .nuops = 1, .uops = { { _RETURN_GENERATOR 0, 0 } } }, - [RETURN_VALUE] = { .nuops = 1, .uops = { { _POP_FRAME 0, 0 } } }, + [RESUME_CHECK] = { .nuops = 1, .uops = { { _RESUME_CHECK, 0, 0 } } }, + [RETURN_CONST] = { .nuops = 2, .uops = { { _LOAD_CONST, 0, 0 }, { _POP_FRAME, 0, 0 } } }, + [RETURN_GENERATOR] = { .nuops = 1, .uops = { { _RETURN_GENERATOR, 0, 0 } } }, + [RETURN_VALUE] = { .nuops = 1, .uops = { { _POP_FRAME, 0, 0 } } }, [SEND] = { .nuops = 0, .uops = { } }, [SEND_GEN] = { .nuops = 0, .uops = { } }, - [SETUP_ANNOTATIONS] = { .nuops = 1, .uops = { { _SETUP_ANNOTATIONS 0, 0 } } }, - [SET_ADD] = { .nuops = 1, .uops = { { _SET_ADD 0, 0 } } }, - [SET_FUNCTION_ATTRIBUTE] = { .nuops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE 0, 0 } } }, - [SET_UPDATE] = { .nuops = 1, .uops = { { _SET_UPDATE 0, 0 } } }, + [SETUP_ANNOTATIONS] = { .nuops = 1, .uops = { { _SETUP_ANNOTATIONS, 0, 0 } } }, + [SET_ADD] = { .nuops = 1, .uops = { { _SET_ADD, 0, 0 } } }, + [SET_FUNCTION_ATTRIBUTE] = { .nuops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE, 0, 0 } } }, + [SET_UPDATE] = { .nuops = 1, .uops = { { _SET_UPDATE, 0, 0 } } }, [STORE_ATTR] = { .nuops = 0, .uops = { } }, - [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 4, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _GUARD_DORV_VALUES 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE 1, 3 } } }, - [STORE_ATTR_SLOT] = { .nuops = 3, .uops = { { unused/1 1, 0 }, { _GUARD_TYPE_VERSION 2, 1 }, { _STORE_ATTR_SLOT 1, 3 } } }, + [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES, 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE, 1, 3 } } }, + [STORE_ATTR_SLOT] = { .nuops = 3, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _STORE_ATTR_SLOT, 1, 3 } } }, [STORE_ATTR_WITH_HINT] = { .nuops = 0, .uops = { } }, - [STORE_DEREF] = { .nuops = 1, .uops = { { _STORE_DEREF 0, 0 } } }, - [STORE_FAST] = { .nuops = 1, .uops = { { _STORE_FAST 0, 0 } } }, - [STORE_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _STORE_FAST 5, 0 }, { _LOAD_FAST 6, 0 } } }, - [STORE_FAST_STORE_FAST] = { .nuops = 2, .uops = { { _STORE_FAST 5, 0 }, { _STORE_FAST 6, 0 } } }, - [STORE_GLOBAL] = { .nuops = 1, .uops = { { _STORE_GLOBAL 0, 0 } } }, - [STORE_NAME] = { .nuops = 1, .uops = { { _STORE_NAME 0, 0 } } }, - [STORE_SLICE] = { .nuops = 1, .uops = { { _STORE_SLICE 0, 0 } } }, + [STORE_DEREF] = { .nuops = 1, .uops = { { _STORE_DEREF, 0, 0 } } }, + [STORE_FAST] = { .nuops = 1, .uops = { { _STORE_FAST, 0, 0 } } }, + [STORE_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _STORE_FAST, 5, 0 }, { _LOAD_FAST, 6, 0 } } }, + [STORE_FAST_STORE_FAST] = { .nuops = 2, .uops = { { _STORE_FAST, 5, 0 }, { _STORE_FAST, 6, 0 } } }, + [STORE_GLOBAL] = { .nuops = 1, .uops = { { _STORE_GLOBAL, 0, 0 } } }, + [STORE_NAME] = { .nuops = 1, .uops = { { _STORE_NAME, 0, 0 } } }, + [STORE_SLICE] = { .nuops = 1, .uops = { { _STORE_SLICE, 0, 0 } } }, [STORE_SUBSCR] = { .nuops = 0, .uops = { } }, - [STORE_SUBSCR_DICT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_DICT 1, 0 } } }, - [STORE_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_LIST_INT 1, 0 } } }, - [SWAP] = { .nuops = 1, .uops = { { _SWAP 0, 0 } } }, + [STORE_SUBSCR_DICT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_DICT, 1, 0 } } }, + [STORE_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_LIST_INT, 1, 0 } } }, + [SWAP] = { .nuops = 1, .uops = { { _SWAP, 0, 0 } } }, [TO_BOOL] = { .nuops = 0, .uops = { } }, - [TO_BOOL_ALWAYS_TRUE] = { .nuops = 1, .uops = { { _TO_BOOL_ALWAYS_TRUE 3, 0 } } }, - [TO_BOOL_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL_BOOL 3, 0 } } }, - [TO_BOOL_INT] = { .nuops = 1, .uops = { { _TO_BOOL_INT 3, 0 } } }, - [TO_BOOL_LIST] = { .nuops = 1, .uops = { { _TO_BOOL_LIST 3, 0 } } }, - [TO_BOOL_NONE] = { .nuops = 1, .uops = { { _TO_BOOL_NONE 3, 0 } } }, - [TO_BOOL_STR] = { .nuops = 1, .uops = { { _TO_BOOL_STR 3, 0 } } }, - [UNARY_INVERT] = { .nuops = 1, .uops = { { _UNARY_INVERT 0, 0 } } }, - [UNARY_NEGATIVE] = { .nuops = 1, .uops = { { _UNARY_NEGATIVE 0, 0 } } }, - [UNARY_NOT] = { .nuops = 1, .uops = { { _UNARY_NOT 0, 0 } } }, - [UNPACK_EX] = { .nuops = 1, .uops = { { _UNPACK_EX 0, 0 } } }, + [TO_BOOL_ALWAYS_TRUE] = { .nuops = 1, .uops = { { _TO_BOOL_ALWAYS_TRUE, 3, 0 } } }, + [TO_BOOL_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL_BOOL, 3, 0 } } }, + [TO_BOOL_INT] = { .nuops = 1, .uops = { { _TO_BOOL_INT, 3, 0 } } }, + [TO_BOOL_LIST] = { .nuops = 1, .uops = { { _TO_BOOL_LIST, 3, 0 } } }, + [TO_BOOL_NONE] = { .nuops = 1, .uops = { { _TO_BOOL_NONE, 3, 0 } } }, + [TO_BOOL_STR] = { .nuops = 1, .uops = { { _TO_BOOL_STR, 3, 0 } } }, + [UNARY_INVERT] = { .nuops = 1, .uops = { { _UNARY_INVERT, 0, 0 } } }, + [UNARY_NEGATIVE] = { .nuops = 1, .uops = { { _UNARY_NEGATIVE, 0, 0 } } }, + [UNARY_NOT] = { .nuops = 1, .uops = { { _UNARY_NOT, 0, 0 } } }, + [UNPACK_EX] = { .nuops = 1, .uops = { { _UNPACK_EX, 0, 0 } } }, [UNPACK_SEQUENCE] = { .nuops = 0, .uops = { } }, - [UNPACK_SEQUENCE_LIST] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_LIST 1, 0 } } }, - [UNPACK_SEQUENCE_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TUPLE 1, 0 } } }, - [UNPACK_SEQUENCE_TWO_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TWO_TUPLE 1, 0 } } }, - [WITH_EXCEPT_START] = { .nuops = 1, .uops = { { _WITH_EXCEPT_START 0, 0 } } }, - [YIELD_VALUE] = { .nuops = 1, .uops = { { _YIELD_VALUE 0, 0 } } }, + [UNPACK_SEQUENCE_LIST] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_LIST, 1, 0 } } }, + [UNPACK_SEQUENCE_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TUPLE, 1, 0 } } }, + [UNPACK_SEQUENCE_TWO_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TWO_TUPLE, 1, 0 } } }, + [WITH_EXCEPT_START] = { .nuops = 1, .uops = { { _WITH_EXCEPT_START, 0, 0 } } }, + [YIELD_VALUE] = { .nuops = 1, .uops = { { _YIELD_VALUE, 0, 0 } } }, }; #endif // NEED_OPCODE_METADATA diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index cc103c4f8a6e02..ae6a321cbe3dcb 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -154,7 +154,7 @@ def generate_expansion_table( expansions: list[tuple[str, int, int]] = [] # [(name, size, offset), ...] if inst.is_super(): pieces = inst.name.split("_") - assert len(pieces) == 4, f"{name} doesn't look like a super-instr" + assert len(pieces) == 4, f"{inst.name} doesn't look like a super-instr" name1 = "_".join(pieces[:2]) name2 = "_".join(pieces[2:]) assert name1 in analysis.instructions, f"{name1} doesn't match any instr" @@ -185,7 +185,7 @@ def generate_expansion_table( out.emit("const struct opcode_macro_expansion\n") out.emit("_PyOpcode_macro_expansion[256] = {\n") for inst_name, expansions in expansions_table.items(): - uops = [f"{{ {name} {size}, {offset} }}" for (name, size, offset) in expansions] + uops = [f"{{ {name}, {size}, {offset} }}" for (name, size, offset) in expansions] out.emit(f"[{inst_name}] = {{ .nuops = {len(expansions)}, .uops = {{ {", ".join(uops)} }} }},\n") out.emit("};\n") out.emit("#endif // NEED_OPCODE_METADATA\n\n") From ff553aeb798cf81d40bc78f45e78e2a331bc030f Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 03:26:48 +0000 Subject: [PATCH 12/51] Fixup expansion table generation --- Include/internal/pycore_opcode_metadata.h | 94 ++++--------------- Python/bytecodes.c | 12 +-- Python/generated_cases.c.h | 3 + .../opcode_metadata_generator.py | 7 +- 4 files changed, 34 insertions(+), 82 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 3385415023a26a..20a07327374ade 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -285,7 +285,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, }; -#define MAX_UOP_PER_EXPANSION 9 +#define MAX_UOP_PER_EXPANSION 8 struct opcode_macro_expansion { int nuops;struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION]; }; @@ -297,19 +297,16 @@ const struct opcode_macro_expansion _PyOpcode_macro_expansion[256] = { [BEFORE_ASYNC_WITH] = { .nuops = 1, .uops = { { _BEFORE_ASYNC_WITH, 0, 0 } } }, [BEFORE_WITH] = { .nuops = 1, .uops = { { _BEFORE_WITH, 0, 0 } } }, - [BINARY_OP] = { .nuops = 0, .uops = { } }, - [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_ADD_FLOAT, 1, 0 } } }, + [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_ADD_FLOAT, 0, 0 } } }, [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_ADD_INT, 1, 0 } } }, [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_ADD_UNICODE, 1, 0 } } }, [BINARY_OP_INPLACE_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE, 1, 0 } } }, - [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT, 1, 0 } } }, + [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT, 0, 0 } } }, [BINARY_OP_MULTIPLY_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_MULTIPLY_INT, 1, 0 } } }, - [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, 1, 0 } } }, + [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, 0, 0 } } }, [BINARY_OP_SUBTRACT_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_SUBTRACT_INT, 1, 0 } } }, [BINARY_SLICE] = { .nuops = 1, .uops = { { _BINARY_SLICE, 0, 0 } } }, - [BINARY_SUBSCR] = { .nuops = 0, .uops = { } }, [BINARY_SUBSCR_DICT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_DICT, 1, 0 } } }, - [BINARY_SUBSCR_GETITEM] = { .nuops = 0, .uops = { } }, [BINARY_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT, 1, 0 } } }, [BINARY_SUBSCR_STR_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_STR_INT, 1, 0 } } }, [BINARY_SUBSCR_TUPLE_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_TUPLE_INT, 1, 0 } } }, @@ -321,33 +318,26 @@ _PyOpcode_macro_expansion[256] = { [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING, 0, 0 } } }, [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE, 0, 0 } } }, [CACHE] = { .nuops = 1, .uops = { { _CACHE, 0, 0 } } }, - [CALL] = { .nuops = 0, .uops = { } }, - [CALL_ALLOC_AND_ENTER_INIT] = { .nuops = 0, .uops = { } }, - [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 9, .uops = { { unused/1, 1, 0 }, { _CHECK_PEP_523, 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, + [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 8, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, [CALL_BUILTIN_CLASS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_CLASS, 3, 0 } } }, [CALL_BUILTIN_FAST] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST, 3, 0 } } }, [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST_WITH_KEYWORDS, 3, 0 } } }, [CALL_BUILTIN_O] = { .nuops = 1, .uops = { { _CALL_BUILTIN_O, 3, 0 } } }, - [CALL_FUNCTION_EX] = { .nuops = 0, .uops = { } }, [CALL_INTRINSIC_1] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_1, 0, 0 } } }, [CALL_INTRINSIC_2] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_2, 0, 0 } } }, [CALL_ISINSTANCE] = { .nuops = 1, .uops = { { _CALL_ISINSTANCE, 3, 0 } } }, - [CALL_KW] = { .nuops = 0, .uops = { } }, [CALL_LEN] = { .nuops = 1, .uops = { { _CALL_LEN, 3, 0 } } }, [CALL_LIST_APPEND] = { .nuops = 1, .uops = { { _CALL_LIST_APPEND, 3, 0 } } }, [CALL_METHOD_DESCRIPTOR_FAST] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST, 3, 0 } } }, [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, 3, 0 } } }, [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_NOARGS, 3, 0 } } }, [CALL_METHOD_DESCRIPTOR_O] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_O, 3, 0 } } }, - [CALL_PY_EXACT_ARGS] = { .nuops = 7, .uops = { { unused/1, 1, 0 }, { _CHECK_PEP_523, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, - [CALL_PY_WITH_DEFAULTS] = { .nuops = 0, .uops = { } }, + [CALL_PY_EXACT_ARGS] = { .nuops = 6, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, [CALL_STR_1] = { .nuops = 1, .uops = { { _CALL_STR_1, 3, 0 } } }, [CALL_TUPLE_1] = { .nuops = 1, .uops = { { _CALL_TUPLE_1, 3, 0 } } }, [CALL_TYPE_1] = { .nuops = 1, .uops = { { _CALL_TYPE_1, 3, 0 } } }, [CHECK_EG_MATCH] = { .nuops = 1, .uops = { { _CHECK_EG_MATCH, 0, 0 } } }, [CHECK_EXC_MATCH] = { .nuops = 1, .uops = { { _CHECK_EXC_MATCH, 0, 0 } } }, - [CLEANUP_THROW] = { .nuops = 0, .uops = { } }, - [COMPARE_OP] = { .nuops = 0, .uops = { } }, [COMPARE_OP_FLOAT] = { .nuops = 1, .uops = { { _COMPARE_OP_FLOAT, 1, 0 } } }, [COMPARE_OP_INT] = { .nuops = 1, .uops = { { _COMPARE_OP_INT, 1, 0 } } }, [COMPARE_OP_STR] = { .nuops = 1, .uops = { { _COMPARE_OP_STR, 1, 0 } } }, @@ -363,7 +353,6 @@ _PyOpcode_macro_expansion[256] = { [DELETE_SUBSCR] = { .nuops = 1, .uops = { { _DELETE_SUBSCR, 0, 0 } } }, [DICT_MERGE] = { .nuops = 1, .uops = { { _DICT_MERGE, 0, 0 } } }, [DICT_UPDATE] = { .nuops = 1, .uops = { { _DICT_UPDATE, 0, 0 } } }, - [END_ASYNC_FOR] = { .nuops = 0, .uops = { } }, [END_FOR] = { .nuops = 2, .uops = { { _POP_TOP, 0, 0 }, { _POP_TOP, 0, 0 } } }, [END_SEND] = { .nuops = 1, .uops = { { _END_SEND, 0, 0 } } }, [ENTER_EXECUTOR] = { .nuops = 1, .uops = { { _ENTER_EXECUTOR, 0, 0 } } }, @@ -371,11 +360,6 @@ _PyOpcode_macro_expansion[256] = { [EXTENDED_ARG] = { .nuops = 1, .uops = { { _EXTENDED_ARG, 0, 0 } } }, [FORMAT_SIMPLE] = { .nuops = 1, .uops = { { _FORMAT_SIMPLE, 0, 0 } } }, [FORMAT_WITH_SPEC] = { .nuops = 1, .uops = { { _FORMAT_WITH_SPEC, 0, 0 } } }, - [FOR_ITER] = { .nuops = 0, .uops = { } }, - [FOR_ITER_GEN] = { .nuops = 0, .uops = { } }, - [FOR_ITER_LIST] = { .nuops = 0, .uops = { } }, - [FOR_ITER_RANGE] = { .nuops = 0, .uops = { } }, - [FOR_ITER_TUPLE] = { .nuops = 0, .uops = { } }, [GET_AITER] = { .nuops = 1, .uops = { { _GET_AITER, 0, 0 } } }, [GET_ANEXT] = { .nuops = 1, .uops = { { _GET_ANEXT, 0, 0 } } }, [GET_AWAITABLE] = { .nuops = 1, .uops = { { _GET_AWAITABLE, 0, 0 } } }, @@ -384,45 +368,23 @@ _PyOpcode_macro_expansion[256] = { [GET_YIELD_FROM_ITER] = { .nuops = 1, .uops = { { _GET_YIELD_FROM_ITER, 0, 0 } } }, [IMPORT_FROM] = { .nuops = 1, .uops = { { _IMPORT_FROM, 0, 0 } } }, [IMPORT_NAME] = { .nuops = 1, .uops = { { _IMPORT_NAME, 0, 0 } } }, - [INSTRUMENTED_CALL] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_CALL_FUNCTION_EX] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_CALL_KW] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_END_FOR] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_END_SEND] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_FOR_ITER] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_INSTRUCTION] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_JUMP_BACKWARD] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_JUMP_FORWARD] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_LOAD_SUPER_ATTR] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_POP_JUMP_IF_NONE] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_RESUME] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_RETURN_CONST] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_RETURN_VALUE] = { .nuops = 0, .uops = { } }, - [INSTRUMENTED_YIELD_VALUE] = { .nuops = 0, .uops = { } }, [INTERPRETER_EXIT] = { .nuops = 1, .uops = { { _INTERPRETER_EXIT, 0, 0 } } }, [IS_OP] = { .nuops = 1, .uops = { { _IS_OP, 0, 0 } } }, - [JUMP_BACKWARD] = { .nuops = 0, .uops = { } }, [JUMP_BACKWARD_NO_INTERRUPT] = { .nuops = 1, .uops = { { _JUMP_BACKWARD_NO_INTERRUPT, 0, 0 } } }, [JUMP_FORWARD] = { .nuops = 1, .uops = { { _JUMP_FORWARD, 0, 0 } } }, [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND, 0, 0 } } }, [LIST_EXTEND] = { .nuops = 1, .uops = { { _LIST_EXTEND, 0, 0 } } }, [LOAD_ASSERTION_ERROR] = { .nuops = 1, .uops = { { _LOAD_ASSERTION_ERROR, 0, 0 } } }, - [LOAD_ATTR] = { .nuops = 0, .uops = { } }, - [LOAD_ATTR_CLASS] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _CHECK_ATTR_CLASS, 2, 1 }, { unused/2, 2, 3 }, { _LOAD_ATTR_CLASS, 4, 5 } } }, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { .nuops = 0, .uops = { } }, - [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES, 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE, 1, 3 }, { unused/5, 5, 4 } } }, - [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT, 0, 0 }, { unused/2, 2, 3 }, { _LOAD_ATTR_METHOD_LAZY_DICT, 4, 5 } } }, - [LOAD_ATTR_METHOD_NO_DICT] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { unused/2, 2, 3 }, { _LOAD_ATTR_METHOD_NO_DICT, 4, 5 } } }, - [LOAD_ATTR_METHOD_WITH_VALUES] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, 0, 0 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES, 4, 5 } } }, - [LOAD_ATTR_MODULE] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _CHECK_ATTR_MODULE, 2, 1 }, { _LOAD_ATTR_MODULE, 1, 3 }, { unused/5, 5, 4 } } }, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { unused/2, 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT, 4, 5 } } }, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, 0, 0 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES, 4, 5 } } }, - [LOAD_ATTR_PROPERTY] = { .nuops = 0, .uops = { } }, - [LOAD_ATTR_SLOT] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_SLOT, 1, 3 }, { unused/5, 5, 4 } } }, - [LOAD_ATTR_WITH_HINT] = { .nuops = 5, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_WITH_HINT, 0, 0 }, { _LOAD_ATTR_WITH_HINT, 1, 3 }, { unused/5, 5, 4 } } }, + [LOAD_ATTR_CLASS] = { .nuops = 2, .uops = { { _CHECK_ATTR_CLASS, 2, 1 }, { _LOAD_ATTR_CLASS, 4, 5 } } }, + [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES, 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE, 1, 3 } } }, + [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT, 0, 0 }, { _LOAD_ATTR_METHOD_LAZY_DICT, 4, 5 } } }, + [LOAD_ATTR_METHOD_NO_DICT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_METHOD_NO_DICT, 4, 5 } } }, + [LOAD_ATTR_METHOD_WITH_VALUES] = { .nuops = 4, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, 0, 0 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_METHOD_WITH_VALUES, 4, 5 } } }, + [LOAD_ATTR_MODULE] = { .nuops = 2, .uops = { { _CHECK_ATTR_MODULE, 2, 1 }, { _LOAD_ATTR_MODULE, 1, 3 } } }, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_NONDESCRIPTOR_NO_DICT, 4, 5 } } }, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { .nuops = 4, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, 0, 0 }, { _GUARD_KEYS_VERSION, 2, 3 }, { _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES, 4, 5 } } }, + [LOAD_ATTR_SLOT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _LOAD_ATTR_SLOT, 1, 3 } } }, + [LOAD_ATTR_WITH_HINT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_WITH_HINT, 0, 0 }, { _LOAD_ATTR_WITH_HINT, 1, 3 } } }, [LOAD_BUILD_CLASS] = { .nuops = 1, .uops = { { _LOAD_BUILD_CLASS, 0, 0 } } }, [LOAD_CONST] = { .nuops = 1, .uops = { { _LOAD_CONST, 0, 0 } } }, [LOAD_DEREF] = { .nuops = 1, .uops = { { _LOAD_DEREF, 0, 0 } } }, @@ -432,12 +394,10 @@ _PyOpcode_macro_expansion[256] = { [LOAD_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _LOAD_FAST, 5, 0 }, { _LOAD_FAST, 6, 0 } } }, [LOAD_FROM_DICT_OR_DEREF] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF, 0, 0 } } }, [LOAD_FROM_DICT_OR_GLOBALS] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_GLOBALS, 0, 0 } } }, - [LOAD_GLOBAL] = { .nuops = 0, .uops = { } }, - [LOAD_GLOBAL_BUILTIN] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_GLOBALS_VERSION, 1, 1 }, { _GUARD_BUILTINS_VERSION, 1, 2 }, { _LOAD_GLOBAL_BUILTINS, 1, 3 } } }, - [LOAD_GLOBAL_MODULE] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_GLOBALS_VERSION, 1, 1 }, { unused/1, 1, 2 }, { _LOAD_GLOBAL_MODULE, 1, 3 } } }, + [LOAD_GLOBAL_BUILTIN] = { .nuops = 3, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _GUARD_BUILTINS_VERSION, 1, 2 }, { _LOAD_GLOBAL_BUILTINS, 1, 3 } } }, + [LOAD_GLOBAL_MODULE] = { .nuops = 2, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _LOAD_GLOBAL_MODULE, 1, 3 } } }, [LOAD_LOCALS] = { .nuops = 1, .uops = { { _LOAD_LOCALS, 0, 0 } } }, [LOAD_NAME] = { .nuops = 1, .uops = { { _LOAD_NAME, 0, 0 } } }, - [LOAD_SUPER_ATTR] = { .nuops = 0, .uops = { } }, [LOAD_SUPER_ATTR_ATTR] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_ATTR, 1, 0 } } }, [LOAD_SUPER_ATTR_METHOD] = { .nuops = 1, .uops = { { _LOAD_SUPER_ATTR_METHOD, 1, 0 } } }, [MAKE_CELL] = { .nuops = 1, .uops = { { _MAKE_CELL, 0, 0 } } }, @@ -449,31 +409,20 @@ _PyOpcode_macro_expansion[256] = { [MATCH_SEQUENCE] = { .nuops = 1, .uops = { { _MATCH_SEQUENCE, 0, 0 } } }, [NOP] = { .nuops = 1, .uops = { { _NOP, 0, 0 } } }, [POP_EXCEPT] = { .nuops = 1, .uops = { { _POP_EXCEPT, 0, 0 } } }, - [POP_JUMP_IF_FALSE] = { .nuops = 0, .uops = { } }, - [POP_JUMP_IF_NONE] = { .nuops = 0, .uops = { } }, - [POP_JUMP_IF_NOT_NONE] = { .nuops = 0, .uops = { } }, - [POP_JUMP_IF_TRUE] = { .nuops = 0, .uops = { } }, [POP_TOP] = { .nuops = 1, .uops = { { _POP_TOP, 0, 0 } } }, [PUSH_EXC_INFO] = { .nuops = 1, .uops = { { _PUSH_EXC_INFO, 0, 0 } } }, [PUSH_NULL] = { .nuops = 1, .uops = { { _PUSH_NULL, 0, 0 } } }, - [RAISE_VARARGS] = { .nuops = 0, .uops = { } }, - [RERAISE] = { .nuops = 0, .uops = { } }, [RESERVED] = { .nuops = 1, .uops = { { _RESERVED, 0, 0 } } }, - [RESUME] = { .nuops = 0, .uops = { } }, [RESUME_CHECK] = { .nuops = 1, .uops = { { _RESUME_CHECK, 0, 0 } } }, [RETURN_CONST] = { .nuops = 2, .uops = { { _LOAD_CONST, 0, 0 }, { _POP_FRAME, 0, 0 } } }, [RETURN_GENERATOR] = { .nuops = 1, .uops = { { _RETURN_GENERATOR, 0, 0 } } }, [RETURN_VALUE] = { .nuops = 1, .uops = { { _POP_FRAME, 0, 0 } } }, - [SEND] = { .nuops = 0, .uops = { } }, - [SEND_GEN] = { .nuops = 0, .uops = { } }, [SETUP_ANNOTATIONS] = { .nuops = 1, .uops = { { _SETUP_ANNOTATIONS, 0, 0 } } }, [SET_ADD] = { .nuops = 1, .uops = { { _SET_ADD, 0, 0 } } }, [SET_FUNCTION_ATTRIBUTE] = { .nuops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE, 0, 0 } } }, [SET_UPDATE] = { .nuops = 1, .uops = { { _SET_UPDATE, 0, 0 } } }, - [STORE_ATTR] = { .nuops = 0, .uops = { } }, - [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 4, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES, 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE, 1, 3 } } }, - [STORE_ATTR_SLOT] = { .nuops = 3, .uops = { { unused/1, 1, 0 }, { _GUARD_TYPE_VERSION, 2, 1 }, { _STORE_ATTR_SLOT, 1, 3 } } }, - [STORE_ATTR_WITH_HINT] = { .nuops = 0, .uops = { } }, + [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES, 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE, 1, 3 } } }, + [STORE_ATTR_SLOT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _STORE_ATTR_SLOT, 1, 3 } } }, [STORE_DEREF] = { .nuops = 1, .uops = { { _STORE_DEREF, 0, 0 } } }, [STORE_FAST] = { .nuops = 1, .uops = { { _STORE_FAST, 0, 0 } } }, [STORE_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _STORE_FAST, 5, 0 }, { _LOAD_FAST, 6, 0 } } }, @@ -481,11 +430,9 @@ _PyOpcode_macro_expansion[256] = { [STORE_GLOBAL] = { .nuops = 1, .uops = { { _STORE_GLOBAL, 0, 0 } } }, [STORE_NAME] = { .nuops = 1, .uops = { { _STORE_NAME, 0, 0 } } }, [STORE_SLICE] = { .nuops = 1, .uops = { { _STORE_SLICE, 0, 0 } } }, - [STORE_SUBSCR] = { .nuops = 0, .uops = { } }, [STORE_SUBSCR_DICT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_DICT, 1, 0 } } }, [STORE_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_LIST_INT, 1, 0 } } }, [SWAP] = { .nuops = 1, .uops = { { _SWAP, 0, 0 } } }, - [TO_BOOL] = { .nuops = 0, .uops = { } }, [TO_BOOL_ALWAYS_TRUE] = { .nuops = 1, .uops = { { _TO_BOOL_ALWAYS_TRUE, 3, 0 } } }, [TO_BOOL_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL_BOOL, 3, 0 } } }, [TO_BOOL_INT] = { .nuops = 1, .uops = { { _TO_BOOL_INT, 3, 0 } } }, @@ -496,7 +443,6 @@ _PyOpcode_macro_expansion[256] = { [UNARY_NEGATIVE] = { .nuops = 1, .uops = { { _UNARY_NEGATIVE, 0, 0 } } }, [UNARY_NOT] = { .nuops = 1, .uops = { { _UNARY_NOT, 0, 0 } } }, [UNPACK_EX] = { .nuops = 1, .uops = { { _UNPACK_EX, 0, 0 } } }, - [UNPACK_SEQUENCE] = { .nuops = 0, .uops = { } }, [UNPACK_SEQUENCE_LIST] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_LIST, 1, 0 } } }, [UNPACK_SEQUENCE_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TUPLE, 1, 0 } } }, [UNPACK_SEQUENCE_TWO_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TWO_TUPLE, 1, 0 } } }, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 68bb15c2b536eb..bf49720ae2848c 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -452,7 +452,7 @@ dummy_func( DEOPT_IF(!PyFloat_CheckExact(right)); } - op(_BINARY_OP_MULTIPLY_FLOAT, (unused/1, left, right -- res)) { + op(_BINARY_OP_MULTIPLY_FLOAT, (left, right -- res)) { STAT_INC(BINARY_OP, hit); double dres = ((PyFloatObject *)left)->ob_fval * @@ -460,7 +460,7 @@ dummy_func( DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dres, res); } - op(_BINARY_OP_ADD_FLOAT, (unused/1, left, right -- res)) { + op(_BINARY_OP_ADD_FLOAT, (left, right -- res)) { STAT_INC(BINARY_OP, hit); double dres = ((PyFloatObject *)left)->ob_fval + @@ -468,7 +468,7 @@ dummy_func( DECREF_INPUTS_AND_REUSE_FLOAT(left, right, dres, res); } - op(_BINARY_OP_SUBTRACT_FLOAT, (unused/1, left, right -- res)) { + op(_BINARY_OP_SUBTRACT_FLOAT, (left, right -- res)) { STAT_INC(BINARY_OP, hit); double dres = ((PyFloatObject *)left)->ob_fval - @@ -477,11 +477,11 @@ dummy_func( } macro(BINARY_OP_MULTIPLY_FLOAT) = - _GUARD_BOTH_FLOAT + _BINARY_OP_MULTIPLY_FLOAT; + _GUARD_BOTH_FLOAT + unused/1 + _BINARY_OP_MULTIPLY_FLOAT; macro(BINARY_OP_ADD_FLOAT) = - _GUARD_BOTH_FLOAT + _BINARY_OP_ADD_FLOAT; + _GUARD_BOTH_FLOAT + unused/1 + _BINARY_OP_ADD_FLOAT; macro(BINARY_OP_SUBTRACT_FLOAT) = - _GUARD_BOTH_FLOAT + _BINARY_OP_SUBTRACT_FLOAT; + _GUARD_BOTH_FLOAT + unused/1 + _BINARY_OP_SUBTRACT_FLOAT; op(_GUARD_BOTH_UNICODE, (left, right -- left, right)) { DEOPT_IF(!PyUnicode_CheckExact(left)); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index a0b7b7db5cc76e..71f9b6245b4cd0 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -153,6 +153,7 @@ DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP); } + /* Skip 1 cache entry */ // _BINARY_OP_ADD_FLOAT { STAT_INC(BINARY_OP, hit); @@ -281,6 +282,7 @@ DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP); } + /* Skip 1 cache entry */ // _BINARY_OP_MULTIPLY_FLOAT { STAT_INC(BINARY_OP, hit); @@ -337,6 +339,7 @@ DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP); } + /* Skip 1 cache entry */ // _BINARY_OP_SUBTRACT_FLOAT { STAT_INC(BINARY_OP, hit); diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index ae6a321cbe3dcb..08fc9f0ba3c789 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -165,12 +165,15 @@ def generate_expansion_table( assert len(instr2.parts) == 1, f"{name2} is not a good superinstruction part" expansions.append((instr1.parts[0].name, OPARG_SIZES["OPARG_TOP"], 0)) expansions.append((instr2.parts[0].name, OPARG_SIZES["OPARG_BOTTOM"], 0)) - elif is_viable_expansion(inst): + elif not is_viable_expansion(inst): + continue + else: for part in inst.parts: size = part.size if part.name == "_SAVE_RETURN_OFFSET": size = OPARG_SIZES["OPARG_SAVE_RETURN_OFFSET"] - expansions.append((part.name, size, offset if size else 0)) + if isinstance(part, Uop): + expansions.append((part.name, size, offset if size else 0)) offset += part.size expansions_table[inst.name] = expansions max_uops = max (len(ex) for ex in expansions_table.values()) From e35ff9b7ff9a7bc985d7215d96541b31da6a2628 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 03:31:12 +0000 Subject: [PATCH 13/51] Fixup expansion table generation --- Include/internal/pycore_opcode_metadata.h | 10 +++++----- Python/bytecodes.c | 20 ++++++++++---------- Python/generated_cases.c.h | 5 +++++ 3 files changed, 20 insertions(+), 15 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 20a07327374ade..e0d11ff8ce4b24 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -298,13 +298,13 @@ _PyOpcode_macro_expansion[256] = { [BEFORE_ASYNC_WITH] = { .nuops = 1, .uops = { { _BEFORE_ASYNC_WITH, 0, 0 } } }, [BEFORE_WITH] = { .nuops = 1, .uops = { { _BEFORE_WITH, 0, 0 } } }, [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_ADD_FLOAT, 0, 0 } } }, - [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_ADD_INT, 1, 0 } } }, - [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_ADD_UNICODE, 1, 0 } } }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE, 1, 0 } } }, + [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_ADD_INT, 0, 0 } } }, + [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_ADD_UNICODE, 0, 0 } } }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE, 0, 0 } } }, [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT, 0, 0 } } }, - [BINARY_OP_MULTIPLY_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_MULTIPLY_INT, 1, 0 } } }, + [BINARY_OP_MULTIPLY_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_MULTIPLY_INT, 0, 0 } } }, [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, 0, 0 } } }, - [BINARY_OP_SUBTRACT_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_SUBTRACT_INT, 1, 0 } } }, + [BINARY_OP_SUBTRACT_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_SUBTRACT_INT, 0, 0 } } }, [BINARY_SLICE] = { .nuops = 1, .uops = { { _BINARY_SLICE, 0, 0 } } }, [BINARY_SUBSCR_DICT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_DICT, 1, 0 } } }, [BINARY_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT, 1, 0 } } }, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index bf49720ae2848c..10111f115d68c6 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -416,7 +416,7 @@ dummy_func( DEOPT_IF(!PyLong_CheckExact(right)); } - op(_BINARY_OP_MULTIPLY_INT, (unused/1, left, right -- res)) { + op(_BINARY_OP_MULTIPLY_INT, (left, right -- res)) { STAT_INC(BINARY_OP, hit); res = _PyLong_Multiply((PyLongObject *)left, (PyLongObject *)right); _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free); @@ -424,7 +424,7 @@ dummy_func( ERROR_IF(res == NULL, error); } - op(_BINARY_OP_ADD_INT, (unused/1, left, right -- res)) { + op(_BINARY_OP_ADD_INT, (left, right -- res)) { STAT_INC(BINARY_OP, hit); res = _PyLong_Add((PyLongObject *)left, (PyLongObject *)right); _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free); @@ -432,7 +432,7 @@ dummy_func( ERROR_IF(res == NULL, error); } - op(_BINARY_OP_SUBTRACT_INT, (unused/1, left, right -- res)) { + op(_BINARY_OP_SUBTRACT_INT, (left, right -- res)) { STAT_INC(BINARY_OP, hit); res = _PyLong_Subtract((PyLongObject *)left, (PyLongObject *)right); _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free); @@ -441,11 +441,11 @@ dummy_func( } macro(BINARY_OP_MULTIPLY_INT) = - _GUARD_BOTH_INT + _BINARY_OP_MULTIPLY_INT; + _GUARD_BOTH_INT + unused/1 + _BINARY_OP_MULTIPLY_INT; macro(BINARY_OP_ADD_INT) = - _GUARD_BOTH_INT + _BINARY_OP_ADD_INT; + _GUARD_BOTH_INT + unused/1 + _BINARY_OP_ADD_INT; macro(BINARY_OP_SUBTRACT_INT) = - _GUARD_BOTH_INT + _BINARY_OP_SUBTRACT_INT; + _GUARD_BOTH_INT + unused/1 + _BINARY_OP_SUBTRACT_INT; op(_GUARD_BOTH_FLOAT, (left, right -- left, right)) { DEOPT_IF(!PyFloat_CheckExact(left)); @@ -488,7 +488,7 @@ dummy_func( DEOPT_IF(!PyUnicode_CheckExact(right)); } - op(_BINARY_OP_ADD_UNICODE, (unused/1, left, right -- res)) { + op(_BINARY_OP_ADD_UNICODE, (left, right -- res)) { STAT_INC(BINARY_OP, hit); res = PyUnicode_Concat(left, right); _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc); @@ -497,7 +497,7 @@ dummy_func( } macro(BINARY_OP_ADD_UNICODE) = - _GUARD_BOTH_UNICODE + _BINARY_OP_ADD_UNICODE; + _GUARD_BOTH_UNICODE + unused/1 + _BINARY_OP_ADD_UNICODE; // This is a subtle one. It's a super-instruction for // BINARY_OP_ADD_UNICODE followed by STORE_FAST @@ -505,7 +505,7 @@ dummy_func( // So the inputs are the same as for all BINARY_OP // specializations, but there is no output. // At the end we just skip over the STORE_FAST. - op(_BINARY_OP_INPLACE_ADD_UNICODE, (unused/1, left, right --)) { + op(_BINARY_OP_INPLACE_ADD_UNICODE, (left, right --)) { assert(next_instr->op.code == STORE_FAST); PyObject **target_local = &GETLOCAL(next_instr->op.arg); DEOPT_IF(*target_local != left); @@ -532,7 +532,7 @@ dummy_func( } macro(BINARY_OP_INPLACE_ADD_UNICODE) = - _GUARD_BOTH_UNICODE + _BINARY_OP_INPLACE_ADD_UNICODE; + _GUARD_BOTH_UNICODE + unused/1 + _BINARY_OP_INPLACE_ADD_UNICODE; family(BINARY_SUBSCR, INLINE_CACHE_ENTRIES_BINARY_SUBSCR) = { BINARY_SUBSCR_DICT, diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 71f9b6245b4cd0..cd065022217ee7 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -182,6 +182,7 @@ DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP); } + /* Skip 1 cache entry */ // _BINARY_OP_ADD_INT { STAT_INC(BINARY_OP, hit); @@ -210,6 +211,7 @@ DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP); DEOPT_IF(!PyUnicode_CheckExact(right), BINARY_OP); } + /* Skip 1 cache entry */ // _BINARY_OP_ADD_UNICODE { STAT_INC(BINARY_OP, hit); @@ -237,6 +239,7 @@ DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP); DEOPT_IF(!PyUnicode_CheckExact(right), BINARY_OP); } + /* Skip 1 cache entry */ // _BINARY_OP_INPLACE_ADD_UNICODE { assert(next_instr->op.code == STORE_FAST); @@ -311,6 +314,7 @@ DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP); } + /* Skip 1 cache entry */ // _BINARY_OP_MULTIPLY_INT { STAT_INC(BINARY_OP, hit); @@ -368,6 +372,7 @@ DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP); } + /* Skip 1 cache entry */ // _BINARY_OP_SUBTRACT_INT { STAT_INC(BINARY_OP, hit); From 15d5f7e0dbc60d5909e965f8d17f8c4d8198fe76 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 03:52:08 +0000 Subject: [PATCH 14/51] Add EXTRA_CASES --- Include/internal/pycore_opcode_metadata.h | 672 ++++++++++-------- Tools/cases_generator/analyzer.py | 77 ++ Tools/cases_generator/opcode_id_generator.py | 91 +-- .../opcode_metadata_generator.py | 16 +- 4 files changed, 467 insertions(+), 389 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index e0d11ff8ce4b24..235eb2ce9b4cdf 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -451,317 +451,6 @@ _PyOpcode_macro_expansion[256] = { }; #endif // NEED_OPCODE_METADATA -extern const uint8_t _PyOpcode_Deopt[256]; -#ifdef NEED_OPCODE_METADATA -const uint8_t _PyOpcode_Deopt[256] = { - [NOP] = NOP, - [RESUME] = RESUME, - [RESUME_CHECK] = RESUME, - [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, - [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, - [LOAD_FAST] = LOAD_FAST, - [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, - [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, - [LOAD_CONST] = LOAD_CONST, - [STORE_FAST] = STORE_FAST, - [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, - [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, - [POP_TOP] = POP_TOP, - [PUSH_NULL] = PUSH_NULL, - [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, - [END_SEND] = END_SEND, - [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, - [UNARY_NEGATIVE] = UNARY_NEGATIVE, - [UNARY_NOT] = UNARY_NOT, - [TO_BOOL_BOOL] = TO_BOOL, - [TO_BOOL_INT] = TO_BOOL, - [TO_BOOL_LIST] = TO_BOOL, - [TO_BOOL_NONE] = TO_BOOL, - [TO_BOOL_STR] = TO_BOOL, - [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, - [UNARY_INVERT] = UNARY_INVERT, - [BINARY_SLICE] = BINARY_SLICE, - [STORE_SLICE] = STORE_SLICE, - [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, - [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, - [LIST_APPEND] = LIST_APPEND, - [SET_ADD] = SET_ADD, - [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, - [STORE_SUBSCR_DICT] = STORE_SUBSCR, - [DELETE_SUBSCR] = DELETE_SUBSCR, - [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, - [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, - [RAISE_VARARGS] = RAISE_VARARGS, - [INTERPRETER_EXIT] = INTERPRETER_EXIT, - [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, - [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST, - [GET_AITER] = GET_AITER, - [GET_ANEXT] = GET_ANEXT, - [GET_AWAITABLE] = GET_AWAITABLE, - [SEND_GEN] = SEND, - [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, - [YIELD_VALUE] = YIELD_VALUE, - [POP_EXCEPT] = POP_EXCEPT, - [RERAISE] = RERAISE, - [END_ASYNC_FOR] = END_ASYNC_FOR, - [CLEANUP_THROW] = CLEANUP_THROW, - [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, - [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, - [STORE_NAME] = STORE_NAME, - [DELETE_NAME] = DELETE_NAME, - [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, - [UNPACK_EX] = UNPACK_EX, - [DELETE_ATTR] = DELETE_ATTR, - [STORE_GLOBAL] = STORE_GLOBAL, - [DELETE_GLOBAL] = DELETE_GLOBAL, - [LOAD_LOCALS] = LOAD_LOCALS, - [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, - [LOAD_NAME] = LOAD_NAME, - [DELETE_FAST] = DELETE_FAST, - [MAKE_CELL] = MAKE_CELL, - [DELETE_DEREF] = DELETE_DEREF, - [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, - [LOAD_DEREF] = LOAD_DEREF, - [STORE_DEREF] = STORE_DEREF, - [COPY_FREE_VARS] = COPY_FREE_VARS, - [BUILD_STRING] = BUILD_STRING, - [BUILD_TUPLE] = BUILD_TUPLE, - [BUILD_LIST] = BUILD_LIST, - [LIST_EXTEND] = LIST_EXTEND, - [SET_UPDATE] = SET_UPDATE, - [BUILD_SET] = BUILD_SET, - [BUILD_MAP] = BUILD_MAP, - [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, - [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, - [DICT_UPDATE] = DICT_UPDATE, - [DICT_MERGE] = DICT_MERGE, - [MAP_ADD] = MAP_ADD, - [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, - [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, - [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, - [LOAD_ATTR_PROPERTY] = LOAD_ATTR, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, - [STORE_ATTR_WITH_HINT] = STORE_ATTR, - [COMPARE_OP_FLOAT] = COMPARE_OP, - [COMPARE_OP_INT] = COMPARE_OP, - [COMPARE_OP_STR] = COMPARE_OP, - [IS_OP] = IS_OP, - [CONTAINS_OP] = CONTAINS_OP, - [CHECK_EG_MATCH] = CHECK_EG_MATCH, - [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, - [IMPORT_NAME] = IMPORT_NAME, - [IMPORT_FROM] = IMPORT_FROM, - [JUMP_FORWARD] = JUMP_FORWARD, - [JUMP_BACKWARD] = JUMP_BACKWARD, - [ENTER_EXECUTOR] = ENTER_EXECUTOR, - [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, - [GET_LEN] = GET_LEN, - [MATCH_CLASS] = MATCH_CLASS, - [MATCH_MAPPING] = MATCH_MAPPING, - [MATCH_SEQUENCE] = MATCH_SEQUENCE, - [MATCH_KEYS] = MATCH_KEYS, - [GET_ITER] = GET_ITER, - [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, - [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, - [FOR_ITER_GEN] = FOR_ITER, - [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, - [BEFORE_WITH] = BEFORE_WITH, - [WITH_EXCEPT_START] = WITH_EXCEPT_START, - [PUSH_EXC_INFO] = PUSH_EXC_INFO, - [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, - [CALL_PY_WITH_DEFAULTS] = CALL, - [CALL_TYPE_1] = CALL, - [CALL_STR_1] = CALL, - [CALL_TUPLE_1] = CALL, - [CALL_ALLOC_AND_ENTER_INIT] = CALL, - [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, - [CALL_BUILTIN_CLASS] = CALL, - [CALL_BUILTIN_O] = CALL, - [CALL_BUILTIN_FAST] = CALL, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, - [CALL_LEN] = CALL, - [CALL_ISINSTANCE] = CALL, - [CALL_LIST_APPEND] = CALL, - [CALL_METHOD_DESCRIPTOR_O] = CALL, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, - [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL, - [CALL_METHOD_DESCRIPTOR_FAST] = CALL, - [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, - [CALL_KW] = CALL_KW, - [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, - [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, - [MAKE_FUNCTION] = MAKE_FUNCTION, - [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, - [RETURN_GENERATOR] = RETURN_GENERATOR, - [BUILD_SLICE] = BUILD_SLICE, - [CONVERT_VALUE] = CONVERT_VALUE, - [FORMAT_SIMPLE] = FORMAT_SIMPLE, - [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC, - [COPY] = COPY, - [SWAP] = SWAP, - [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, - [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, - [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, - [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, - [EXTENDED_ARG] = EXTENDED_ARG, - [CACHE] = CACHE, - [RESERVED] = RESERVED, - [END_FOR] = END_FOR, - [TO_BOOL] = TO_BOOL, - [BINARY_OP_MULTIPLY_INT] = BINARY_OP, - [BINARY_OP_ADD_INT] = BINARY_OP, - [BINARY_OP_SUBTRACT_INT] = BINARY_OP, - [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, - [BINARY_OP_ADD_FLOAT] = BINARY_OP, - [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, - [BINARY_OP_ADD_UNICODE] = BINARY_OP, - [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, - [BINARY_SUBSCR] = BINARY_SUBSCR, - [STORE_SUBSCR] = STORE_SUBSCR, - [RETURN_VALUE] = RETURN_VALUE, - [RETURN_CONST] = RETURN_CONST, - [SEND] = SEND, - [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, - [STORE_ATTR] = STORE_ATTR, - [LOAD_GLOBAL] = LOAD_GLOBAL, - [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, - [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, - [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, - [LOAD_ATTR] = LOAD_ATTR, - [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, - [LOAD_ATTR_MODULE] = LOAD_ATTR, - [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, - [LOAD_ATTR_SLOT] = LOAD_ATTR, - [LOAD_ATTR_CLASS] = LOAD_ATTR, - [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, - [STORE_ATTR_SLOT] = STORE_ATTR, - [COMPARE_OP] = COMPARE_OP, - [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, - [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, - [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, - [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, - [FOR_ITER] = FOR_ITER, - [FOR_ITER_LIST] = FOR_ITER, - [FOR_ITER_TUPLE] = FOR_ITER, - [FOR_ITER_RANGE] = FOR_ITER, - [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, - [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, - [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, - [CALL] = CALL, - [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, - [CALL_PY_EXACT_ARGS] = CALL, - [BINARY_OP] = BINARY_OP, -}; - -#endif // NEED_OPCODE_METADATA -const uint8_t _PyOpcode_Caches[256] = { - [TO_BOOL_BOOL] = 3, - [TO_BOOL_INT] = 3, - [TO_BOOL_LIST] = 3, - [TO_BOOL_NONE] = 3, - [TO_BOOL_STR] = 3, - [TO_BOOL_ALWAYS_TRUE] = 3, - [BINARY_SUBSCR_LIST_INT] = 1, - [BINARY_SUBSCR_STR_INT] = 1, - [BINARY_SUBSCR_TUPLE_INT] = 1, - [BINARY_SUBSCR_DICT] = 1, - [BINARY_SUBSCR_GETITEM] = 1, - [STORE_SUBSCR_LIST_INT] = 1, - [STORE_SUBSCR_DICT] = 1, - [SEND_GEN] = 1, - [UNPACK_SEQUENCE_TWO_TUPLE] = 1, - [UNPACK_SEQUENCE_TUPLE] = 1, - [UNPACK_SEQUENCE_LIST] = 1, - [INSTRUMENTED_LOAD_SUPER_ATTR] = 1, - [LOAD_SUPER_ATTR_ATTR] = 1, - [LOAD_SUPER_ATTR_METHOD] = 1, - [LOAD_ATTR_PROPERTY] = 9, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = 9, - [STORE_ATTR_WITH_HINT] = 4, - [COMPARE_OP_FLOAT] = 1, - [COMPARE_OP_INT] = 1, - [COMPARE_OP_STR] = 1, - [JUMP_BACKWARD] = 1, - [INSTRUMENTED_FOR_ITER] = 1, - [FOR_ITER_GEN] = 1, - [INSTRUMENTED_CALL] = 3, - [CALL_PY_WITH_DEFAULTS] = 3, - [CALL_TYPE_1] = 3, - [CALL_STR_1] = 3, - [CALL_TUPLE_1] = 3, - [CALL_ALLOC_AND_ENTER_INIT] = 3, - [CALL_BUILTIN_CLASS] = 3, - [CALL_BUILTIN_O] = 3, - [CALL_BUILTIN_FAST] = 3, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = 3, - [CALL_LEN] = 3, - [CALL_ISINSTANCE] = 3, - [CALL_LIST_APPEND] = 3, - [CALL_METHOD_DESCRIPTOR_O] = 3, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = 3, - [CALL_METHOD_DESCRIPTOR_NOARGS] = 3, - [CALL_METHOD_DESCRIPTOR_FAST] = 3, - [INSTRUMENTED_JUMP_BACKWARD] = 1, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = 1, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = 1, - [INSTRUMENTED_POP_JUMP_IF_NONE] = 1, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = 1, - [TO_BOOL] = 3, - [BINARY_OP_MULTIPLY_INT] = 1, - [BINARY_OP_ADD_INT] = 1, - [BINARY_OP_SUBTRACT_INT] = 1, - [BINARY_OP_MULTIPLY_FLOAT] = 1, - [BINARY_OP_ADD_FLOAT] = 1, - [BINARY_OP_SUBTRACT_FLOAT] = 1, - [BINARY_OP_ADD_UNICODE] = 1, - [BINARY_OP_INPLACE_ADD_UNICODE] = 1, - [BINARY_SUBSCR] = 1, - [STORE_SUBSCR] = 1, - [SEND] = 1, - [UNPACK_SEQUENCE] = 1, - [STORE_ATTR] = 4, - [LOAD_GLOBAL] = 4, - [LOAD_GLOBAL_MODULE] = 4, - [LOAD_GLOBAL_BUILTIN] = 4, - [LOAD_SUPER_ATTR] = 1, - [LOAD_ATTR] = 9, - [LOAD_ATTR_INSTANCE_VALUE] = 9, - [LOAD_ATTR_MODULE] = 9, - [LOAD_ATTR_WITH_HINT] = 9, - [LOAD_ATTR_SLOT] = 9, - [LOAD_ATTR_CLASS] = 9, - [STORE_ATTR_INSTANCE_VALUE] = 4, - [STORE_ATTR_SLOT] = 4, - [COMPARE_OP] = 1, - [POP_JUMP_IF_TRUE] = 1, - [POP_JUMP_IF_FALSE] = 1, - [POP_JUMP_IF_NONE] = 1, - [POP_JUMP_IF_NOT_NONE] = 1, - [FOR_ITER] = 1, - [FOR_ITER_LIST] = 1, - [FOR_ITER_TUPLE] = 1, - [FOR_ITER_RANGE] = 1, - [LOAD_ATTR_METHOD_WITH_VALUES] = 9, - [LOAD_ATTR_METHOD_NO_DICT] = 9, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = 9, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = 9, - [LOAD_ATTR_METHOD_LAZY_DICT] = 9, - [CALL] = 3, - [CALL_BOUND_METHOD_EXACT_ARGS] = 3, - [CALL_PY_EXACT_ARGS] = 3, - [BINARY_OP] = 1, -}; - const char *_PyOpcode_OpName[268] = { [BEFORE_ASYNC_WITH] = "BEFORE_ASYNC_WITH", [BEFORE_WITH] = "BEFORE_WITH", @@ -984,6 +673,367 @@ const char *_PyOpcode_OpName[268] = { [YIELD_VALUE] = "YIELD_VALUE", }; +const uint8_t _PyOpcode_Caches[256] = { + [TO_BOOL_BOOL] = 3, + [TO_BOOL_INT] = 3, + [TO_BOOL_LIST] = 3, + [TO_BOOL_NONE] = 3, + [TO_BOOL_STR] = 3, + [TO_BOOL_ALWAYS_TRUE] = 3, + [BINARY_SUBSCR_LIST_INT] = 1, + [BINARY_SUBSCR_STR_INT] = 1, + [BINARY_SUBSCR_TUPLE_INT] = 1, + [BINARY_SUBSCR_DICT] = 1, + [BINARY_SUBSCR_GETITEM] = 1, + [STORE_SUBSCR_LIST_INT] = 1, + [STORE_SUBSCR_DICT] = 1, + [SEND_GEN] = 1, + [UNPACK_SEQUENCE_TWO_TUPLE] = 1, + [UNPACK_SEQUENCE_TUPLE] = 1, + [UNPACK_SEQUENCE_LIST] = 1, + [INSTRUMENTED_LOAD_SUPER_ATTR] = 1, + [LOAD_SUPER_ATTR_ATTR] = 1, + [LOAD_SUPER_ATTR_METHOD] = 1, + [LOAD_ATTR_PROPERTY] = 9, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = 9, + [STORE_ATTR_WITH_HINT] = 4, + [COMPARE_OP_FLOAT] = 1, + [COMPARE_OP_INT] = 1, + [COMPARE_OP_STR] = 1, + [JUMP_BACKWARD] = 1, + [INSTRUMENTED_FOR_ITER] = 1, + [FOR_ITER_GEN] = 1, + [INSTRUMENTED_CALL] = 3, + [CALL_PY_WITH_DEFAULTS] = 3, + [CALL_TYPE_1] = 3, + [CALL_STR_1] = 3, + [CALL_TUPLE_1] = 3, + [CALL_ALLOC_AND_ENTER_INIT] = 3, + [CALL_BUILTIN_CLASS] = 3, + [CALL_BUILTIN_O] = 3, + [CALL_BUILTIN_FAST] = 3, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = 3, + [CALL_LEN] = 3, + [CALL_ISINSTANCE] = 3, + [CALL_LIST_APPEND] = 3, + [CALL_METHOD_DESCRIPTOR_O] = 3, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = 3, + [CALL_METHOD_DESCRIPTOR_NOARGS] = 3, + [CALL_METHOD_DESCRIPTOR_FAST] = 3, + [INSTRUMENTED_JUMP_BACKWARD] = 1, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = 1, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = 1, + [INSTRUMENTED_POP_JUMP_IF_NONE] = 1, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = 1, + [TO_BOOL] = 3, + [BINARY_OP_MULTIPLY_INT] = 1, + [BINARY_OP_ADD_INT] = 1, + [BINARY_OP_SUBTRACT_INT] = 1, + [BINARY_OP_MULTIPLY_FLOAT] = 1, + [BINARY_OP_ADD_FLOAT] = 1, + [BINARY_OP_SUBTRACT_FLOAT] = 1, + [BINARY_OP_ADD_UNICODE] = 1, + [BINARY_OP_INPLACE_ADD_UNICODE] = 1, + [BINARY_SUBSCR] = 1, + [STORE_SUBSCR] = 1, + [SEND] = 1, + [UNPACK_SEQUENCE] = 1, + [STORE_ATTR] = 4, + [LOAD_GLOBAL] = 4, + [LOAD_GLOBAL_MODULE] = 4, + [LOAD_GLOBAL_BUILTIN] = 4, + [LOAD_SUPER_ATTR] = 1, + [LOAD_ATTR] = 9, + [LOAD_ATTR_INSTANCE_VALUE] = 9, + [LOAD_ATTR_MODULE] = 9, + [LOAD_ATTR_WITH_HINT] = 9, + [LOAD_ATTR_SLOT] = 9, + [LOAD_ATTR_CLASS] = 9, + [STORE_ATTR_INSTANCE_VALUE] = 4, + [STORE_ATTR_SLOT] = 4, + [COMPARE_OP] = 1, + [POP_JUMP_IF_TRUE] = 1, + [POP_JUMP_IF_FALSE] = 1, + [POP_JUMP_IF_NONE] = 1, + [POP_JUMP_IF_NOT_NONE] = 1, + [FOR_ITER] = 1, + [FOR_ITER_LIST] = 1, + [FOR_ITER_TUPLE] = 1, + [FOR_ITER_RANGE] = 1, + [LOAD_ATTR_METHOD_WITH_VALUES] = 9, + [LOAD_ATTR_METHOD_NO_DICT] = 9, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = 9, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = 9, + [LOAD_ATTR_METHOD_LAZY_DICT] = 9, + [CALL] = 3, + [CALL_BOUND_METHOD_EXACT_ARGS] = 3, + [CALL_PY_EXACT_ARGS] = 3, + [BINARY_OP] = 1, +}; + +extern const uint8_t _PyOpcode_Deopt[256]; +#ifdef NEED_OPCODE_METADATA +const uint8_t _PyOpcode_Deopt[256] = { + [NOP] = NOP, + [RESUME] = RESUME, + [RESUME_CHECK] = RESUME, + [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, + [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, + [LOAD_FAST] = LOAD_FAST, + [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, + [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, + [LOAD_CONST] = LOAD_CONST, + [STORE_FAST] = STORE_FAST, + [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, + [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, + [POP_TOP] = POP_TOP, + [PUSH_NULL] = PUSH_NULL, + [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, + [END_SEND] = END_SEND, + [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, + [UNARY_NEGATIVE] = UNARY_NEGATIVE, + [UNARY_NOT] = UNARY_NOT, + [TO_BOOL_BOOL] = TO_BOOL, + [TO_BOOL_INT] = TO_BOOL, + [TO_BOOL_LIST] = TO_BOOL, + [TO_BOOL_NONE] = TO_BOOL, + [TO_BOOL_STR] = TO_BOOL, + [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, + [UNARY_INVERT] = UNARY_INVERT, + [BINARY_SLICE] = BINARY_SLICE, + [STORE_SLICE] = STORE_SLICE, + [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, + [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, + [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, + [LIST_APPEND] = LIST_APPEND, + [SET_ADD] = SET_ADD, + [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, + [STORE_SUBSCR_DICT] = STORE_SUBSCR, + [DELETE_SUBSCR] = DELETE_SUBSCR, + [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, + [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, + [RAISE_VARARGS] = RAISE_VARARGS, + [INTERPRETER_EXIT] = INTERPRETER_EXIT, + [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, + [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST, + [GET_AITER] = GET_AITER, + [GET_ANEXT] = GET_ANEXT, + [GET_AWAITABLE] = GET_AWAITABLE, + [SEND_GEN] = SEND, + [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, + [YIELD_VALUE] = YIELD_VALUE, + [POP_EXCEPT] = POP_EXCEPT, + [RERAISE] = RERAISE, + [END_ASYNC_FOR] = END_ASYNC_FOR, + [CLEANUP_THROW] = CLEANUP_THROW, + [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, + [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, + [STORE_NAME] = STORE_NAME, + [DELETE_NAME] = DELETE_NAME, + [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, + [UNPACK_EX] = UNPACK_EX, + [DELETE_ATTR] = DELETE_ATTR, + [STORE_GLOBAL] = STORE_GLOBAL, + [DELETE_GLOBAL] = DELETE_GLOBAL, + [LOAD_LOCALS] = LOAD_LOCALS, + [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, + [LOAD_NAME] = LOAD_NAME, + [DELETE_FAST] = DELETE_FAST, + [MAKE_CELL] = MAKE_CELL, + [DELETE_DEREF] = DELETE_DEREF, + [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, + [LOAD_DEREF] = LOAD_DEREF, + [STORE_DEREF] = STORE_DEREF, + [COPY_FREE_VARS] = COPY_FREE_VARS, + [BUILD_STRING] = BUILD_STRING, + [BUILD_TUPLE] = BUILD_TUPLE, + [BUILD_LIST] = BUILD_LIST, + [LIST_EXTEND] = LIST_EXTEND, + [SET_UPDATE] = SET_UPDATE, + [BUILD_SET] = BUILD_SET, + [BUILD_MAP] = BUILD_MAP, + [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, + [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, + [DICT_UPDATE] = DICT_UPDATE, + [DICT_MERGE] = DICT_MERGE, + [MAP_ADD] = MAP_ADD, + [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, + [LOAD_ATTR_PROPERTY] = LOAD_ATTR, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, + [STORE_ATTR_WITH_HINT] = STORE_ATTR, + [COMPARE_OP_FLOAT] = COMPARE_OP, + [COMPARE_OP_INT] = COMPARE_OP, + [COMPARE_OP_STR] = COMPARE_OP, + [IS_OP] = IS_OP, + [CONTAINS_OP] = CONTAINS_OP, + [CHECK_EG_MATCH] = CHECK_EG_MATCH, + [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, + [IMPORT_NAME] = IMPORT_NAME, + [IMPORT_FROM] = IMPORT_FROM, + [JUMP_FORWARD] = JUMP_FORWARD, + [JUMP_BACKWARD] = JUMP_BACKWARD, + [ENTER_EXECUTOR] = ENTER_EXECUTOR, + [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, + [GET_LEN] = GET_LEN, + [MATCH_CLASS] = MATCH_CLASS, + [MATCH_MAPPING] = MATCH_MAPPING, + [MATCH_SEQUENCE] = MATCH_SEQUENCE, + [MATCH_KEYS] = MATCH_KEYS, + [GET_ITER] = GET_ITER, + [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, + [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, + [FOR_ITER_GEN] = FOR_ITER, + [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, + [BEFORE_WITH] = BEFORE_WITH, + [WITH_EXCEPT_START] = WITH_EXCEPT_START, + [PUSH_EXC_INFO] = PUSH_EXC_INFO, + [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, + [CALL_PY_WITH_DEFAULTS] = CALL, + [CALL_TYPE_1] = CALL, + [CALL_STR_1] = CALL, + [CALL_TUPLE_1] = CALL, + [CALL_ALLOC_AND_ENTER_INIT] = CALL, + [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, + [CALL_BUILTIN_CLASS] = CALL, + [CALL_BUILTIN_O] = CALL, + [CALL_BUILTIN_FAST] = CALL, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, + [CALL_LEN] = CALL, + [CALL_ISINSTANCE] = CALL, + [CALL_LIST_APPEND] = CALL, + [CALL_METHOD_DESCRIPTOR_O] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, + [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST] = CALL, + [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, + [CALL_KW] = CALL_KW, + [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, + [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, + [MAKE_FUNCTION] = MAKE_FUNCTION, + [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, + [RETURN_GENERATOR] = RETURN_GENERATOR, + [BUILD_SLICE] = BUILD_SLICE, + [CONVERT_VALUE] = CONVERT_VALUE, + [FORMAT_SIMPLE] = FORMAT_SIMPLE, + [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC, + [COPY] = COPY, + [SWAP] = SWAP, + [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, + [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, + [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, + [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, + [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, + [EXTENDED_ARG] = EXTENDED_ARG, + [CACHE] = CACHE, + [RESERVED] = RESERVED, + [END_FOR] = END_FOR, + [TO_BOOL] = TO_BOOL, + [BINARY_OP_MULTIPLY_INT] = BINARY_OP, + [BINARY_OP_ADD_INT] = BINARY_OP, + [BINARY_OP_SUBTRACT_INT] = BINARY_OP, + [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, + [BINARY_OP_ADD_FLOAT] = BINARY_OP, + [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, + [BINARY_OP_ADD_UNICODE] = BINARY_OP, + [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, + [BINARY_SUBSCR] = BINARY_SUBSCR, + [STORE_SUBSCR] = STORE_SUBSCR, + [RETURN_VALUE] = RETURN_VALUE, + [RETURN_CONST] = RETURN_CONST, + [SEND] = SEND, + [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, + [STORE_ATTR] = STORE_ATTR, + [LOAD_GLOBAL] = LOAD_GLOBAL, + [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, + [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, + [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, + [LOAD_ATTR] = LOAD_ATTR, + [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, + [LOAD_ATTR_MODULE] = LOAD_ATTR, + [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, + [LOAD_ATTR_SLOT] = LOAD_ATTR, + [LOAD_ATTR_CLASS] = LOAD_ATTR, + [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, + [STORE_ATTR_SLOT] = STORE_ATTR, + [COMPARE_OP] = COMPARE_OP, + [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, + [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, + [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, + [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, + [FOR_ITER] = FOR_ITER, + [FOR_ITER_LIST] = FOR_ITER, + [FOR_ITER_TUPLE] = FOR_ITER, + [FOR_ITER_RANGE] = FOR_ITER, + [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, + [CALL] = CALL, + [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, + [CALL_PY_EXACT_ARGS] = CALL, + [BINARY_OP] = BINARY_OP, +}; + +#endif // NEED_OPCODE_METADATA +#define EXTRA_CASES \ +case 119: \ +case 120: \ +case 121: \ +case 122: \ +case 123: \ +case 124: \ +case 125: \ +case 126: \ +case 127: \ +case 128: \ +case 129: \ +case 130: \ +case 131: \ +case 132: \ +case 133: \ +case 134: \ +case 135: \ +case 136: \ +case 137: \ +case 138: \ +case 139: \ +case 140: \ +case 141: \ +case 142: \ +case 143: \ +case 144: \ +case 145: \ +case 146: \ +case 147: \ +case 148: \ +case 219: \ +case 220: \ +case 221: \ +case 222: \ +case 223: \ +case 224: \ +case 225: \ +case 226: \ +case 227: \ +case 228: \ +case 229: \ +case 230: \ +case 231: \ +case 232: \ +case 233: \ +case 234: \ +case 235: \ +case 255: \ + ; struct pseudo_targets { uint8_t targets[3]; }; diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index b049df7f7be9f4..944c072bf5ae41 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -225,6 +225,83 @@ class Analysis: families: dict[str, Family] pseudos: dict[str, PseudoInstruction] + def get_instruction_map(self) -> dict[str, int]: + instmap: dict[str, int] = {} + + # 0 is reserved for cache entries. This helps debugging. + instmap["CACHE"] = 0 + + # 17 is reserved as it is the initial value for the specializing counter. + # This helps catch cases where we attempt to execute a cache. + instmap["RESERVED"] = 17 + + # 149 is RESUME - it is hard coded as such in Tools/build/deepfreeze.py + instmap["RESUME"] = 149 + instmap["INSTRUMENTED_LINE"] = 254 + + instrumented = [ + name for name in self.instructions if name.startswith("INSTRUMENTED") + ] + + # Special case: this instruction is implemented in ceval.c + # rather than bytecodes.c, so we need to add it explicitly + # here (at least until we add something to bytecodes.c to + # declare external instructions). + instrumented.append("INSTRUMENTED_LINE") + + specialized: set[str] = set() + no_arg: list[str] = [] + has_arg: list[str] = [] + + for family in self.families.values(): + specialized.update(inst.name for inst in family.members) + + for inst in self.instructions.values(): + name = inst.name + if name in specialized: + continue + if name in instrumented: + continue + if inst.properties.oparg: + has_arg.append(name) + else: + no_arg.append(name) + + # Specialized ops appear in their own section + # Instrumented opcodes are at the end of the valid range + min_internal = 150 + min_instrumented = 254 - (len(instrumented) - 1) + assert min_internal + len(specialized) < min_instrumented + + next_opcode = 1 + + def add_instruction(name: str) -> None: + nonlocal next_opcode + if name in instmap: + return # Pre-defined name + while next_opcode in instmap.values(): + next_opcode += 1 + instmap[name] = next_opcode + next_opcode += 1 + + for name in sorted(no_arg): + add_instruction(name) + for name in sorted(has_arg): + add_instruction(name) + # For compatibility + next_opcode = min_internal + for name in sorted(specialized): + add_instruction(name) + next_opcode = min_instrumented + for name in instrumented: + add_instruction(name) + + for op, name in enumerate(sorted(self.pseudos), 256): + instmap[name] = op + + assert 255 not in instmap.values() + return instmap + def analysis_error(message: str, tkn: lexer.Token) -> SyntaxError: # To do -- support file and line output diff --git a/Tools/cases_generator/opcode_id_generator.py b/Tools/cases_generator/opcode_id_generator.py index b4e1b6fcf8112a..36b92898f67d2c 100644 --- a/Tools/cases_generator/opcode_id_generator.py +++ b/Tools/cases_generator/opcode_id_generator.py @@ -24,84 +24,11 @@ DEFAULT_OUTPUT = ROOT / "Include/opcode_ids.h" + def generate_opcode_header(filenames: list[str], analysis: Analysis, outfile: TextIO) -> None: write_header(__file__, filenames, outfile) out = CWriter(outfile, 0, False) - instmap: dict[str, int] = {} - - # 0 is reserved for cache entries. This helps debugging. - instmap["CACHE"] = 0 - - # 17 is reserved as it is the initial value for the specializing counter. - # This helps catch cases where we attempt to execute a cache. - instmap["RESERVED"] = 17 - - # 149 is RESUME - it is hard coded as such in Tools/build/deepfreeze.py - instmap["RESUME"] = 149 - instmap["INSTRUMENTED_LINE"] = 254 - - instrumented = [ - name for name in analysis.instructions if name.startswith("INSTRUMENTED") - ] - - # Special case: this instruction is implemented in ceval.c - # rather than bytecodes.c, so we need to add it explicitly - # here (at least until we add something to bytecodes.c to - # declare external instructions). - instrumented.append("INSTRUMENTED_LINE") - - specialized: set[str] = set() - no_arg: list[str] = [] - has_arg: list[str] = [] - - for family in analysis.families.values(): - specialized.update(inst.name for inst in family.members) - - for inst in analysis.instructions.values(): - name = inst.name - if name in specialized: - continue - if name in instrumented: - continue - if inst.properties.oparg: - has_arg.append(name) - else: - no_arg.append(name) - - # Specialized ops appear in their own section - # Instrumented opcodes are at the end of the valid range - min_internal = 150 - min_instrumented = 254 - (len(instrumented) - 1) - assert min_internal + len(specialized) < min_instrumented - - next_opcode = 1 - - def add_instruction(name: str) -> None: - nonlocal next_opcode - if name in instmap: - return # Pre-defined name - while next_opcode in instmap.values(): - next_opcode += 1 - instmap[name] = next_opcode - next_opcode += 1 - - for name in sorted(no_arg): - add_instruction(name) - for name in sorted(has_arg): - add_instruction(name) - # For compatibility - next_opcode = min_internal - for name in sorted(specialized): - add_instruction(name) - next_opcode = min_instrumented - for name in instrumented: - add_instruction(name) - - for op, name in enumerate(sorted(analysis.pseudos), 256): - instmap[name] = op - - assert 255 not in instmap.values() - + instmap = analysis.get_instruction_map() with out.header_guard("Py_OPCODE_IDS_H"): out.emit("/* Instruction opcodes for compiled code */\n") @@ -112,7 +39,19 @@ def write_define(name: str, op: int) -> None: write_define(name, op) out.emit("\n") - write_define("HAVE_ARGUMENT", len(no_arg)) + min_instrumented = 256 + first_arg = 256 + for name, op in instmap.items(): + if name.startswith("INSTRUMENTED") and op < min_instrumented: + min_instrumented = op + if name == "INSTRUMENTED_LINE": + # INSTRUMENTED_LINE is not defined + continue + if name in analysis.pseudos: + continue + if analysis.instructions[name].properties.oparg and op < first_arg: + first_arg = op + write_define("HAVE_ARGUMENT", first_arg) write_define("MIN_INSTRUMENTED_OPCODE", min_instrumented) diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 08fc9f0ba3c789..bd320dca934213 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -201,6 +201,17 @@ def is_viable_expansion(inst: Instruction) -> bool: return True +def generate_extra_cases( + analysis: Analysis, out: CWriter +) -> None: + out.emit("#define EXTRA_CASES \\\n") + valid_opcodes = set(analysis.get_instruction_map().values()) + for op in range(256): + if op not in valid_opcodes: + out.emit(f"case {op}: \\\n") + out.emit(" ;\n") + + def generate_psuedo_targets( analysis: Analysis, out: CWriter ) -> None: @@ -251,9 +262,10 @@ def generate_opcode_metadata( generate_flag_macros(out) generate_metadata_table(analysis, out) generate_expansion_table(analysis, out) - generate_deopt_table(analysis, out) - generate_cache_table(analysis, out) generate_name_table(analysis, out) + generate_cache_table(analysis, out) + generate_deopt_table(analysis, out) + generate_extra_cases(analysis, out) generate_psuedo_targets(analysis, out) From 6ac49dfa93172cc56dd548d61eed8aa2ba9d3afd Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 03:58:48 +0000 Subject: [PATCH 15/51] Sort deopts --- Include/internal/pycore_opcode_metadata.h | 356 +++++++++--------- .../opcode_metadata_generator.py | 2 +- 2 files changed, 179 insertions(+), 179 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 235eb2ce9b4cdf..9a19f4bb76ed95 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -774,213 +774,213 @@ const uint8_t _PyOpcode_Caches[256] = { extern const uint8_t _PyOpcode_Deopt[256]; #ifdef NEED_OPCODE_METADATA const uint8_t _PyOpcode_Deopt[256] = { - [NOP] = NOP, - [RESUME] = RESUME, - [RESUME_CHECK] = RESUME, - [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, - [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, - [LOAD_FAST] = LOAD_FAST, - [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, - [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, - [LOAD_CONST] = LOAD_CONST, - [STORE_FAST] = STORE_FAST, - [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, - [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, - [POP_TOP] = POP_TOP, - [PUSH_NULL] = PUSH_NULL, - [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, - [END_SEND] = END_SEND, - [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, - [UNARY_NEGATIVE] = UNARY_NEGATIVE, - [UNARY_NOT] = UNARY_NOT, - [TO_BOOL_BOOL] = TO_BOOL, - [TO_BOOL_INT] = TO_BOOL, - [TO_BOOL_LIST] = TO_BOOL, - [TO_BOOL_NONE] = TO_BOOL, - [TO_BOOL_STR] = TO_BOOL, - [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, - [UNARY_INVERT] = UNARY_INVERT, + [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, + [BEFORE_WITH] = BEFORE_WITH, + [BINARY_OP] = BINARY_OP, + [BINARY_OP_ADD_FLOAT] = BINARY_OP, + [BINARY_OP_ADD_INT] = BINARY_OP, + [BINARY_OP_ADD_UNICODE] = BINARY_OP, + [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, + [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, + [BINARY_OP_MULTIPLY_INT] = BINARY_OP, + [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, + [BINARY_OP_SUBTRACT_INT] = BINARY_OP, [BINARY_SLICE] = BINARY_SLICE, - [STORE_SLICE] = STORE_SLICE, + [BINARY_SUBSCR] = BINARY_SUBSCR, + [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, + [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, [BINARY_SUBSCR_STR_INT] = BINARY_SUBSCR, [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, - [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, - [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, - [LIST_APPEND] = LIST_APPEND, - [SET_ADD] = SET_ADD, - [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, - [STORE_SUBSCR_DICT] = STORE_SUBSCR, - [DELETE_SUBSCR] = DELETE_SUBSCR, - [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, - [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, - [RAISE_VARARGS] = RAISE_VARARGS, - [INTERPRETER_EXIT] = INTERPRETER_EXIT, - [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, - [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST, - [GET_AITER] = GET_AITER, - [GET_ANEXT] = GET_ANEXT, - [GET_AWAITABLE] = GET_AWAITABLE, - [SEND_GEN] = SEND, - [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, - [YIELD_VALUE] = YIELD_VALUE, - [POP_EXCEPT] = POP_EXCEPT, - [RERAISE] = RERAISE, - [END_ASYNC_FOR] = END_ASYNC_FOR, - [CLEANUP_THROW] = CLEANUP_THROW, - [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, - [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, - [STORE_NAME] = STORE_NAME, - [DELETE_NAME] = DELETE_NAME, - [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, - [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, - [UNPACK_EX] = UNPACK_EX, - [DELETE_ATTR] = DELETE_ATTR, - [STORE_GLOBAL] = STORE_GLOBAL, - [DELETE_GLOBAL] = DELETE_GLOBAL, - [LOAD_LOCALS] = LOAD_LOCALS, - [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, - [LOAD_NAME] = LOAD_NAME, - [DELETE_FAST] = DELETE_FAST, - [MAKE_CELL] = MAKE_CELL, - [DELETE_DEREF] = DELETE_DEREF, - [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, - [LOAD_DEREF] = LOAD_DEREF, - [STORE_DEREF] = STORE_DEREF, - [COPY_FREE_VARS] = COPY_FREE_VARS, - [BUILD_STRING] = BUILD_STRING, - [BUILD_TUPLE] = BUILD_TUPLE, + [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, [BUILD_LIST] = BUILD_LIST, - [LIST_EXTEND] = LIST_EXTEND, - [SET_UPDATE] = SET_UPDATE, - [BUILD_SET] = BUILD_SET, [BUILD_MAP] = BUILD_MAP, - [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, - [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, - [DICT_UPDATE] = DICT_UPDATE, - [DICT_MERGE] = DICT_MERGE, - [MAP_ADD] = MAP_ADD, - [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, - [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, - [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, - [LOAD_ATTR_PROPERTY] = LOAD_ATTR, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, - [STORE_ATTR_WITH_HINT] = STORE_ATTR, - [COMPARE_OP_FLOAT] = COMPARE_OP, - [COMPARE_OP_INT] = COMPARE_OP, - [COMPARE_OP_STR] = COMPARE_OP, - [IS_OP] = IS_OP, - [CONTAINS_OP] = CONTAINS_OP, - [CHECK_EG_MATCH] = CHECK_EG_MATCH, - [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, - [IMPORT_NAME] = IMPORT_NAME, - [IMPORT_FROM] = IMPORT_FROM, - [JUMP_FORWARD] = JUMP_FORWARD, - [JUMP_BACKWARD] = JUMP_BACKWARD, - [ENTER_EXECUTOR] = ENTER_EXECUTOR, - [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, - [GET_LEN] = GET_LEN, - [MATCH_CLASS] = MATCH_CLASS, - [MATCH_MAPPING] = MATCH_MAPPING, - [MATCH_SEQUENCE] = MATCH_SEQUENCE, - [MATCH_KEYS] = MATCH_KEYS, - [GET_ITER] = GET_ITER, - [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, - [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, - [FOR_ITER_GEN] = FOR_ITER, - [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, - [BEFORE_WITH] = BEFORE_WITH, - [WITH_EXCEPT_START] = WITH_EXCEPT_START, - [PUSH_EXC_INFO] = PUSH_EXC_INFO, - [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, - [CALL_PY_WITH_DEFAULTS] = CALL, - [CALL_TYPE_1] = CALL, - [CALL_STR_1] = CALL, - [CALL_TUPLE_1] = CALL, + [BUILD_SET] = BUILD_SET, + [BUILD_SLICE] = BUILD_SLICE, + [BUILD_STRING] = BUILD_STRING, + [BUILD_TUPLE] = BUILD_TUPLE, + [CACHE] = CACHE, + [CALL] = CALL, [CALL_ALLOC_AND_ENTER_INIT] = CALL, - [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, + [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, [CALL_BUILTIN_CLASS] = CALL, - [CALL_BUILTIN_O] = CALL, [CALL_BUILTIN_FAST] = CALL, [CALL_BUILTIN_FAST_WITH_KEYWORDS] = CALL, - [CALL_LEN] = CALL, + [CALL_BUILTIN_O] = CALL, + [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, + [CALL_INTRINSIC_1] = CALL_INTRINSIC_1, + [CALL_INTRINSIC_2] = CALL_INTRINSIC_2, [CALL_ISINSTANCE] = CALL, + [CALL_KW] = CALL_KW, + [CALL_LEN] = CALL, [CALL_LIST_APPEND] = CALL, - [CALL_METHOD_DESCRIPTOR_O] = CALL, + [CALL_METHOD_DESCRIPTOR_FAST] = CALL, [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = CALL, [CALL_METHOD_DESCRIPTOR_NOARGS] = CALL, - [CALL_METHOD_DESCRIPTOR_FAST] = CALL, - [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, - [CALL_KW] = CALL_KW, - [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, - [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, - [MAKE_FUNCTION] = MAKE_FUNCTION, - [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, - [RETURN_GENERATOR] = RETURN_GENERATOR, - [BUILD_SLICE] = BUILD_SLICE, + [CALL_METHOD_DESCRIPTOR_O] = CALL, + [CALL_PY_EXACT_ARGS] = CALL, + [CALL_PY_WITH_DEFAULTS] = CALL, + [CALL_STR_1] = CALL, + [CALL_TUPLE_1] = CALL, + [CALL_TYPE_1] = CALL, + [CHECK_EG_MATCH] = CHECK_EG_MATCH, + [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, + [CLEANUP_THROW] = CLEANUP_THROW, + [COMPARE_OP] = COMPARE_OP, + [COMPARE_OP_FLOAT] = COMPARE_OP, + [COMPARE_OP_INT] = COMPARE_OP, + [COMPARE_OP_STR] = COMPARE_OP, + [CONTAINS_OP] = CONTAINS_OP, [CONVERT_VALUE] = CONVERT_VALUE, + [COPY] = COPY, + [COPY_FREE_VARS] = COPY_FREE_VARS, + [DELETE_ATTR] = DELETE_ATTR, + [DELETE_DEREF] = DELETE_DEREF, + [DELETE_FAST] = DELETE_FAST, + [DELETE_GLOBAL] = DELETE_GLOBAL, + [DELETE_NAME] = DELETE_NAME, + [DELETE_SUBSCR] = DELETE_SUBSCR, + [DICT_MERGE] = DICT_MERGE, + [DICT_UPDATE] = DICT_UPDATE, + [END_ASYNC_FOR] = END_ASYNC_FOR, + [END_FOR] = END_FOR, + [END_SEND] = END_SEND, + [ENTER_EXECUTOR] = ENTER_EXECUTOR, + [EXIT_INIT_CHECK] = EXIT_INIT_CHECK, + [EXTENDED_ARG] = EXTENDED_ARG, [FORMAT_SIMPLE] = FORMAT_SIMPLE, [FORMAT_WITH_SPEC] = FORMAT_WITH_SPEC, - [COPY] = COPY, - [SWAP] = SWAP, + [FOR_ITER] = FOR_ITER, + [FOR_ITER_GEN] = FOR_ITER, + [FOR_ITER_LIST] = FOR_ITER, + [FOR_ITER_RANGE] = FOR_ITER, + [FOR_ITER_TUPLE] = FOR_ITER, + [GET_AITER] = GET_AITER, + [GET_ANEXT] = GET_ANEXT, + [GET_AWAITABLE] = GET_AWAITABLE, + [GET_ITER] = GET_ITER, + [GET_LEN] = GET_LEN, + [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, + [IMPORT_FROM] = IMPORT_FROM, + [IMPORT_NAME] = IMPORT_NAME, + [INSTRUMENTED_CALL] = INSTRUMENTED_CALL, + [INSTRUMENTED_CALL_FUNCTION_EX] = INSTRUMENTED_CALL_FUNCTION_EX, + [INSTRUMENTED_CALL_KW] = INSTRUMENTED_CALL_KW, + [INSTRUMENTED_END_FOR] = INSTRUMENTED_END_FOR, + [INSTRUMENTED_END_SEND] = INSTRUMENTED_END_SEND, + [INSTRUMENTED_FOR_ITER] = INSTRUMENTED_FOR_ITER, [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, - [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, + [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = INSTRUMENTED_POP_JUMP_IF_NOT_NONE, - [EXTENDED_ARG] = EXTENDED_ARG, - [CACHE] = CACHE, - [RESERVED] = RESERVED, - [END_FOR] = END_FOR, - [TO_BOOL] = TO_BOOL, - [BINARY_OP_MULTIPLY_INT] = BINARY_OP, - [BINARY_OP_ADD_INT] = BINARY_OP, - [BINARY_OP_SUBTRACT_INT] = BINARY_OP, - [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, - [BINARY_OP_ADD_FLOAT] = BINARY_OP, - [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, - [BINARY_OP_ADD_UNICODE] = BINARY_OP, - [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, - [BINARY_SUBSCR] = BINARY_SUBSCR, - [STORE_SUBSCR] = STORE_SUBSCR, - [RETURN_VALUE] = RETURN_VALUE, - [RETURN_CONST] = RETURN_CONST, - [SEND] = SEND, - [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, - [STORE_ATTR] = STORE_ATTR, - [LOAD_GLOBAL] = LOAD_GLOBAL, - [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, - [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, - [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, + [INSTRUMENTED_POP_JUMP_IF_TRUE] = INSTRUMENTED_POP_JUMP_IF_TRUE, + [INSTRUMENTED_RESUME] = INSTRUMENTED_RESUME, + [INSTRUMENTED_RETURN_CONST] = INSTRUMENTED_RETURN_CONST, + [INSTRUMENTED_RETURN_VALUE] = INSTRUMENTED_RETURN_VALUE, + [INSTRUMENTED_YIELD_VALUE] = INSTRUMENTED_YIELD_VALUE, + [INTERPRETER_EXIT] = INTERPRETER_EXIT, + [IS_OP] = IS_OP, + [JUMP_BACKWARD] = JUMP_BACKWARD, + [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, + [JUMP_FORWARD] = JUMP_FORWARD, + [LIST_APPEND] = LIST_APPEND, + [LIST_EXTEND] = LIST_EXTEND, + [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, [LOAD_ATTR] = LOAD_ATTR, + [LOAD_ATTR_CLASS] = LOAD_ATTR, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = LOAD_ATTR, [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, + [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, + [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, [LOAD_ATTR_MODULE] = LOAD_ATTR, - [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, + [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, + [LOAD_ATTR_PROPERTY] = LOAD_ATTR, [LOAD_ATTR_SLOT] = LOAD_ATTR, - [LOAD_ATTR_CLASS] = LOAD_ATTR, - [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, - [STORE_ATTR_SLOT] = STORE_ATTR, - [COMPARE_OP] = COMPARE_OP, - [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, + [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, + [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, + [LOAD_CONST] = LOAD_CONST, + [LOAD_DEREF] = LOAD_DEREF, + [LOAD_FAST] = LOAD_FAST, + [LOAD_FAST_AND_CLEAR] = LOAD_FAST_AND_CLEAR, + [LOAD_FAST_CHECK] = LOAD_FAST_CHECK, + [LOAD_FAST_LOAD_FAST] = LOAD_FAST_LOAD_FAST, + [LOAD_FROM_DICT_OR_DEREF] = LOAD_FROM_DICT_OR_DEREF, + [LOAD_FROM_DICT_OR_GLOBALS] = LOAD_FROM_DICT_OR_GLOBALS, + [LOAD_GLOBAL] = LOAD_GLOBAL, + [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, + [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, + [LOAD_LOCALS] = LOAD_LOCALS, + [LOAD_NAME] = LOAD_NAME, + [LOAD_SUPER_ATTR] = LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_ATTR] = LOAD_SUPER_ATTR, + [LOAD_SUPER_ATTR_METHOD] = LOAD_SUPER_ATTR, + [MAKE_CELL] = MAKE_CELL, + [MAKE_FUNCTION] = MAKE_FUNCTION, + [MAP_ADD] = MAP_ADD, + [MATCH_CLASS] = MATCH_CLASS, + [MATCH_KEYS] = MATCH_KEYS, + [MATCH_MAPPING] = MATCH_MAPPING, + [MATCH_SEQUENCE] = MATCH_SEQUENCE, + [NOP] = NOP, + [POP_EXCEPT] = POP_EXCEPT, [POP_JUMP_IF_FALSE] = POP_JUMP_IF_FALSE, [POP_JUMP_IF_NONE] = POP_JUMP_IF_NONE, [POP_JUMP_IF_NOT_NONE] = POP_JUMP_IF_NOT_NONE, - [FOR_ITER] = FOR_ITER, - [FOR_ITER_LIST] = FOR_ITER, - [FOR_ITER_TUPLE] = FOR_ITER, - [FOR_ITER_RANGE] = FOR_ITER, - [LOAD_ATTR_METHOD_WITH_VALUES] = LOAD_ATTR, - [LOAD_ATTR_METHOD_NO_DICT] = LOAD_ATTR, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = LOAD_ATTR, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = LOAD_ATTR, - [LOAD_ATTR_METHOD_LAZY_DICT] = LOAD_ATTR, - [CALL] = CALL, - [CALL_BOUND_METHOD_EXACT_ARGS] = CALL, - [CALL_PY_EXACT_ARGS] = CALL, - [BINARY_OP] = BINARY_OP, + [POP_JUMP_IF_TRUE] = POP_JUMP_IF_TRUE, + [POP_TOP] = POP_TOP, + [PUSH_EXC_INFO] = PUSH_EXC_INFO, + [PUSH_NULL] = PUSH_NULL, + [RAISE_VARARGS] = RAISE_VARARGS, + [RERAISE] = RERAISE, + [RESERVED] = RESERVED, + [RESUME] = RESUME, + [RESUME_CHECK] = RESUME, + [RETURN_CONST] = RETURN_CONST, + [RETURN_GENERATOR] = RETURN_GENERATOR, + [RETURN_VALUE] = RETURN_VALUE, + [SEND] = SEND, + [SEND_GEN] = SEND, + [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, + [SET_ADD] = SET_ADD, + [SET_FUNCTION_ATTRIBUTE] = SET_FUNCTION_ATTRIBUTE, + [SET_UPDATE] = SET_UPDATE, + [STORE_ATTR] = STORE_ATTR, + [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, + [STORE_ATTR_SLOT] = STORE_ATTR, + [STORE_ATTR_WITH_HINT] = STORE_ATTR, + [STORE_DEREF] = STORE_DEREF, + [STORE_FAST] = STORE_FAST, + [STORE_FAST_LOAD_FAST] = STORE_FAST_LOAD_FAST, + [STORE_FAST_STORE_FAST] = STORE_FAST_STORE_FAST, + [STORE_GLOBAL] = STORE_GLOBAL, + [STORE_NAME] = STORE_NAME, + [STORE_SLICE] = STORE_SLICE, + [STORE_SUBSCR] = STORE_SUBSCR, + [STORE_SUBSCR_DICT] = STORE_SUBSCR, + [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, + [SWAP] = SWAP, + [TO_BOOL] = TO_BOOL, + [TO_BOOL_ALWAYS_TRUE] = TO_BOOL, + [TO_BOOL_BOOL] = TO_BOOL, + [TO_BOOL_INT] = TO_BOOL, + [TO_BOOL_LIST] = TO_BOOL, + [TO_BOOL_NONE] = TO_BOOL, + [TO_BOOL_STR] = TO_BOOL, + [UNARY_INVERT] = UNARY_INVERT, + [UNARY_NEGATIVE] = UNARY_NEGATIVE, + [UNARY_NOT] = UNARY_NOT, + [UNPACK_EX] = UNPACK_EX, + [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, + [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, + [WITH_EXCEPT_START] = WITH_EXCEPT_START, + [YIELD_VALUE] = YIELD_VALUE, }; #endif // NEED_OPCODE_METADATA diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index bd320dca934213..879fdccf6ad335 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -102,7 +102,7 @@ def generate_deopt_table( out.emit("extern const uint8_t _PyOpcode_Deopt[256];\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const uint8_t _PyOpcode_Deopt[256] = {\n") - for inst in analysis.instructions.values(): + for inst in sorted(analysis.instructions.values(), key=lambda t:t.name): deopt = inst.name if inst.family is not None: deopt = inst.family.name From 78a009dbb59f50b6ed270eeb051f8c077f6a13c6 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 04:15:06 +0000 Subject: [PATCH 16/51] fix whitespace --- Include/internal/pycore_opcode_metadata.h | 98 +++++++++---------- .../opcode_metadata_generator.py | 4 +- 2 files changed, 51 insertions(+), 51 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 9a19f4bb76ed95..63feea57c9f9df 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -985,55 +985,55 @@ const uint8_t _PyOpcode_Deopt[256] = { #endif // NEED_OPCODE_METADATA #define EXTRA_CASES \ -case 119: \ -case 120: \ -case 121: \ -case 122: \ -case 123: \ -case 124: \ -case 125: \ -case 126: \ -case 127: \ -case 128: \ -case 129: \ -case 130: \ -case 131: \ -case 132: \ -case 133: \ -case 134: \ -case 135: \ -case 136: \ -case 137: \ -case 138: \ -case 139: \ -case 140: \ -case 141: \ -case 142: \ -case 143: \ -case 144: \ -case 145: \ -case 146: \ -case 147: \ -case 148: \ -case 219: \ -case 220: \ -case 221: \ -case 222: \ -case 223: \ -case 224: \ -case 225: \ -case 226: \ -case 227: \ -case 228: \ -case 229: \ -case 230: \ -case 231: \ -case 232: \ -case 233: \ -case 234: \ -case 235: \ -case 255: \ - ; + case 119: \ + case 120: \ + case 121: \ + case 122: \ + case 123: \ + case 124: \ + case 125: \ + case 126: \ + case 127: \ + case 128: \ + case 129: \ + case 130: \ + case 131: \ + case 132: \ + case 133: \ + case 134: \ + case 135: \ + case 136: \ + case 137: \ + case 138: \ + case 139: \ + case 140: \ + case 141: \ + case 142: \ + case 143: \ + case 144: \ + case 145: \ + case 146: \ + case 147: \ + case 148: \ + case 219: \ + case 220: \ + case 221: \ + case 222: \ + case 223: \ + case 224: \ + case 225: \ + case 226: \ + case 227: \ + case 228: \ + case 229: \ + case 230: \ + case 231: \ + case 232: \ + case 233: \ + case 234: \ + case 235: \ + case 255: \ + ; struct pseudo_targets { uint8_t targets[3]; }; diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 879fdccf6ad335..258a3b47e9efb5 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -208,8 +208,8 @@ def generate_extra_cases( valid_opcodes = set(analysis.get_instruction_map().values()) for op in range(256): if op not in valid_opcodes: - out.emit(f"case {op}: \\\n") - out.emit(" ;\n") + out.emit(f" case {op}: \\\n") + out.emit(" ;\n") def generate_psuedo_targets( From 7a71863b03c7bf99f7c3a306d421d363d03d62f5 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 04:20:35 +0000 Subject: [PATCH 17/51] Add INSTRUMENTED_LINE --- Include/internal/pycore_opcode_metadata.h | 3 +++ Tools/cases_generator/opcode_metadata_generator.py | 11 ++++++++--- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 63feea57c9f9df..64cd6a9ee2a9de 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -550,6 +550,7 @@ const char *_PyOpcode_OpName[268] = { [INSTRUMENTED_INSTRUCTION] = "INSTRUMENTED_INSTRUCTION", [INSTRUMENTED_JUMP_BACKWARD] = "INSTRUMENTED_JUMP_BACKWARD", [INSTRUMENTED_JUMP_FORWARD] = "INSTRUMENTED_JUMP_FORWARD", + [INSTRUMENTED_LINE] = "INSTRUMENTED_LINE", [INSTRUMENTED_LOAD_SUPER_ATTR] = "INSTRUMENTED_LOAD_SUPER_ATTR", [INSTRUMENTED_POP_JUMP_IF_FALSE] = "INSTRUMENTED_POP_JUMP_IF_FALSE", [INSTRUMENTED_POP_JUMP_IF_NONE] = "INSTRUMENTED_POP_JUMP_IF_NONE", @@ -872,6 +873,7 @@ const uint8_t _PyOpcode_Deopt[256] = { [INSTRUMENTED_INSTRUCTION] = INSTRUMENTED_INSTRUCTION, [INSTRUMENTED_JUMP_BACKWARD] = INSTRUMENTED_JUMP_BACKWARD, [INSTRUMENTED_JUMP_FORWARD] = INSTRUMENTED_JUMP_FORWARD, + [INSTRUMENTED_LINE] = INSTRUMENTED_LINE, [INSTRUMENTED_LOAD_SUPER_ATTR] = INSTRUMENTED_LOAD_SUPER_ATTR, [INSTRUMENTED_POP_JUMP_IF_FALSE] = INSTRUMENTED_POP_JUMP_IF_FALSE, [INSTRUMENTED_POP_JUMP_IF_NONE] = INSTRUMENTED_POP_JUMP_IF_NONE, @@ -984,6 +986,7 @@ const uint8_t _PyOpcode_Deopt[256] = { }; #endif // NEED_OPCODE_METADATA + #define EXTRA_CASES \ case 119: \ case 120: \ diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 258a3b47e9efb5..feef5b4b4d950c 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -102,13 +102,17 @@ def generate_deopt_table( out.emit("extern const uint8_t _PyOpcode_Deopt[256];\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const uint8_t _PyOpcode_Deopt[256] = {\n") - for inst in sorted(analysis.instructions.values(), key=lambda t:t.name): + deopts: list[tuple[str, str]] = [] + for inst in analysis.instructions.values(): deopt = inst.name if inst.family is not None: deopt = inst.family.name - out.emit(f"[{inst.name}] = {deopt},\n") + deopts.append((inst.name, deopt)) + deopts.append(("INSTRUMENTED_LINE", "INSTRUMENTED_LINE")) + for name, deopt in sorted(deopts): + out.emit(f"[{name}] = {deopt},\n") out.emit("};\n\n") - out.emit("#endif // NEED_OPCODE_METADATA\n") + out.emit("#endif // NEED_OPCODE_METADATA\n\n") def generate_cache_table( @@ -127,6 +131,7 @@ def generate_name_table( table_size = 256 + len(analysis.pseudos) out.emit(f"const char *_PyOpcode_OpName[{table_size}] = {{\n") names = list(analysis.instructions) + list(analysis.pseudos) + names.append("INSTRUMENTED_LINE") for name in sorted(names): out.emit(f'[{name}] = "{name}",\n') out.emit("};\n\n") From 22acca37742025d5a215c64bfed70a4b42d25c1e Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 06:39:34 +0000 Subject: [PATCH 18/51] Add pop/push stack effect functions --- Include/internal/pycore_opcode_metadata.h | 850 ++++++++++++++++++ .../opcode_metadata_generator.py | 35 + Tools/cases_generator/stack.py | 25 +- 3 files changed, 909 insertions(+), 1 deletion(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 64cd6a9ee2a9de..a4c157a43e781c 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -33,6 +33,856 @@ extern "C" { 0) #include "pycore_uop_ids.h" +extern int _PyOpcode_num_popped(int opcode, int oparg); +#ifdef NEED_OPCODE_METADATA +int _PyOpcode_num_popped(int opcode, int oparg) { + switch(opcode) { + case BEFORE_ASYNC_WITH: + return 1; + case BEFORE_WITH: + return 1; + case BINARY_OP: + return 2; + case BINARY_OP_ADD_FLOAT: + return 2; + case BINARY_OP_ADD_INT: + return 2; + case BINARY_OP_ADD_UNICODE: + return 2; + case BINARY_OP_INPLACE_ADD_UNICODE: + return 2; + case BINARY_OP_MULTIPLY_FLOAT: + return 2; + case BINARY_OP_MULTIPLY_INT: + return 2; + case BINARY_OP_SUBTRACT_FLOAT: + return 2; + case BINARY_OP_SUBTRACT_INT: + return 2; + case BINARY_SLICE: + return 3; + case BINARY_SUBSCR: + return 2; + case BINARY_SUBSCR_DICT: + return 2; + case BINARY_SUBSCR_GETITEM: + return 2; + case BINARY_SUBSCR_LIST_INT: + return 2; + case BINARY_SUBSCR_STR_INT: + return 2; + case BINARY_SUBSCR_TUPLE_INT: + return 2; + case BUILD_CONST_KEY_MAP: + return 1 + oparg; + case BUILD_LIST: + return oparg; + case BUILD_MAP: + return oparg*2; + case BUILD_SET: + return oparg; + case BUILD_SLICE: + return 2 + (((oparg == 3) ? 1 : 0)); + case BUILD_STRING: + return oparg; + case BUILD_TUPLE: + return oparg; + case CACHE: + return 0; + case CALL: + return 2 + oparg; + case CALL_ALLOC_AND_ENTER_INIT: + return 2 + oparg; + case CALL_BOUND_METHOD_EXACT_ARGS: + return 2 + oparg; + case CALL_BUILTIN_CLASS: + return 2 + oparg; + case CALL_BUILTIN_FAST: + return 2 + oparg; + case CALL_BUILTIN_FAST_WITH_KEYWORDS: + return 2 + oparg; + case CALL_BUILTIN_O: + return 2 + oparg; + case CALL_FUNCTION_EX: + return 3 + ((oparg & 1)); + case CALL_INTRINSIC_1: + return 1; + case CALL_INTRINSIC_2: + return 2; + case CALL_ISINSTANCE: + return 2 + oparg; + case CALL_KW: + return 3 + oparg; + case CALL_LEN: + return 2 + oparg; + case CALL_LIST_APPEND: + return 2 + oparg; + case CALL_METHOD_DESCRIPTOR_FAST: + return 2 + oparg; + case CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: + return 2 + oparg; + case CALL_METHOD_DESCRIPTOR_NOARGS: + return 2 + oparg; + case CALL_METHOD_DESCRIPTOR_O: + return 2 + oparg; + case CALL_PY_EXACT_ARGS: + return 2 + oparg; + case CALL_PY_WITH_DEFAULTS: + return 2 + oparg; + case CALL_STR_1: + return 2 + oparg; + case CALL_TUPLE_1: + return 2 + oparg; + case CALL_TYPE_1: + return 2 + oparg; + case CHECK_EG_MATCH: + return 2; + case CHECK_EXC_MATCH: + return 2; + case CLEANUP_THROW: + return 3; + case COMPARE_OP: + return 2; + case COMPARE_OP_FLOAT: + return 2; + case COMPARE_OP_INT: + return 2; + case COMPARE_OP_STR: + return 2; + case CONTAINS_OP: + return 2; + case CONVERT_VALUE: + return 1; + case COPY: + return 1 + (oparg-1); + case COPY_FREE_VARS: + return 0; + case DELETE_ATTR: + return 1; + case DELETE_DEREF: + return 0; + case DELETE_FAST: + return 0; + case DELETE_GLOBAL: + return 0; + case DELETE_NAME: + return 0; + case DELETE_SUBSCR: + return 2; + case DICT_MERGE: + return 5 + (oparg - 1); + case DICT_UPDATE: + return 2 + (oparg - 1); + case END_ASYNC_FOR: + return 2; + case END_FOR: + return 2; + case END_SEND: + return 2; + case ENTER_EXECUTOR: + return 0; + case EXIT_INIT_CHECK: + return 1; + case EXTENDED_ARG: + return 0; + case FORMAT_SIMPLE: + return 1; + case FORMAT_WITH_SPEC: + return 2; + case FOR_ITER: + return 1; + case FOR_ITER_GEN: + return 1; + case FOR_ITER_LIST: + return 1; + case FOR_ITER_RANGE: + return 1; + case FOR_ITER_TUPLE: + return 1; + case GET_AITER: + return 1; + case GET_ANEXT: + return 1; + case GET_AWAITABLE: + return 1; + case GET_ITER: + return 1; + case GET_LEN: + return 1; + case GET_YIELD_FROM_ITER: + return 1; + case IMPORT_FROM: + return 1; + case IMPORT_NAME: + return 2; + case INSTRUMENTED_CALL: + return 0; + case INSTRUMENTED_CALL_FUNCTION_EX: + return 0; + case INSTRUMENTED_CALL_KW: + return 0; + case INSTRUMENTED_END_FOR: + return 2; + case INSTRUMENTED_END_SEND: + return 2; + case INSTRUMENTED_FOR_ITER: + return 0; + case INSTRUMENTED_INSTRUCTION: + return 0; + case INSTRUMENTED_JUMP_BACKWARD: + return 0; + case INSTRUMENTED_JUMP_FORWARD: + return 0; + case INSTRUMENTED_LOAD_SUPER_ATTR: + return 3; + case INSTRUMENTED_POP_JUMP_IF_FALSE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_NONE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_NOT_NONE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_TRUE: + return 0; + case INSTRUMENTED_RESUME: + return 0; + case INSTRUMENTED_RETURN_CONST: + return 0; + case INSTRUMENTED_RETURN_VALUE: + return 1; + case INSTRUMENTED_YIELD_VALUE: + return 1; + case INTERPRETER_EXIT: + return 1; + case IS_OP: + return 2; + case JUMP_BACKWARD: + return 0; + case JUMP_BACKWARD_NO_INTERRUPT: + return 0; + case JUMP_FORWARD: + return 0; + case LIST_APPEND: + return 2 + (oparg-1); + case LIST_EXTEND: + return 2 + (oparg-1); + case LOAD_ASSERTION_ERROR: + return 0; + case LOAD_ATTR: + return 1; + case LOAD_ATTR_CLASS: + return 1; + case LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN: + return 1; + case LOAD_ATTR_INSTANCE_VALUE: + return 1; + case LOAD_ATTR_METHOD_LAZY_DICT: + return 1; + case LOAD_ATTR_METHOD_NO_DICT: + return 1; + case LOAD_ATTR_METHOD_WITH_VALUES: + return 1; + case LOAD_ATTR_MODULE: + return 1; + case LOAD_ATTR_NONDESCRIPTOR_NO_DICT: + return 1; + case LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: + return 1; + case LOAD_ATTR_PROPERTY: + return 1; + case LOAD_ATTR_SLOT: + return 1; + case LOAD_ATTR_WITH_HINT: + return 1; + case LOAD_BUILD_CLASS: + return 0; + case LOAD_CONST: + return 0; + case LOAD_DEREF: + return 0; + case LOAD_FAST: + return 0; + case LOAD_FAST_AND_CLEAR: + return 0; + case LOAD_FAST_CHECK: + return 0; + case LOAD_FAST_LOAD_FAST: + return 0; + case LOAD_FROM_DICT_OR_DEREF: + return 1; + case LOAD_FROM_DICT_OR_GLOBALS: + return 1; + case LOAD_GLOBAL: + return 0; + case LOAD_GLOBAL_BUILTIN: + return 0; + case LOAD_GLOBAL_MODULE: + return 0; + case LOAD_LOCALS: + return 0; + case LOAD_NAME: + return 0; + case LOAD_SUPER_ATTR: + return 3; + case LOAD_SUPER_ATTR_ATTR: + return 3; + case LOAD_SUPER_ATTR_METHOD: + return 3; + case MAKE_CELL: + return 0; + case MAKE_FUNCTION: + return 1; + case MAP_ADD: + return 3 + (oparg - 1); + case MATCH_CLASS: + return 3; + case MATCH_KEYS: + return 2; + case MATCH_MAPPING: + return 1; + case MATCH_SEQUENCE: + return 1; + case NOP: + return 0; + case POP_EXCEPT: + return 1; + case POP_JUMP_IF_FALSE: + return 1; + case POP_JUMP_IF_NONE: + return 1; + case POP_JUMP_IF_NOT_NONE: + return 1; + case POP_JUMP_IF_TRUE: + return 1; + case POP_TOP: + return 1; + case PUSH_EXC_INFO: + return 1; + case PUSH_NULL: + return 0; + case RAISE_VARARGS: + return oparg; + case RERAISE: + return 1 + oparg; + case RESERVED: + return 0; + case RESUME: + return 0; + case RESUME_CHECK: + return 0; + case RETURN_CONST: + return 0; + case RETURN_GENERATOR: + return 0; + case RETURN_VALUE: + return 1; + case SEND: + return 2; + case SEND_GEN: + return 2; + case SETUP_ANNOTATIONS: + return 0; + case SET_ADD: + return 2 + (oparg-1); + case SET_FUNCTION_ATTRIBUTE: + return 2; + case SET_UPDATE: + return 2 + (oparg-1); + case STORE_ATTR: + return 2; + case STORE_ATTR_INSTANCE_VALUE: + return 2; + case STORE_ATTR_SLOT: + return 2; + case STORE_ATTR_WITH_HINT: + return 2; + case STORE_DEREF: + return 1; + case STORE_FAST: + return 1; + case STORE_FAST_LOAD_FAST: + return 1; + case STORE_FAST_STORE_FAST: + return 2; + case STORE_GLOBAL: + return 1; + case STORE_NAME: + return 1; + case STORE_SLICE: + return 4; + case STORE_SUBSCR: + return 3; + case STORE_SUBSCR_DICT: + return 3; + case STORE_SUBSCR_LIST_INT: + return 3; + case SWAP: + return 2 + (oparg-2); + case TO_BOOL: + return 1; + case TO_BOOL_ALWAYS_TRUE: + return 1; + case TO_BOOL_BOOL: + return 1; + case TO_BOOL_INT: + return 1; + case TO_BOOL_LIST: + return 1; + case TO_BOOL_NONE: + return 1; + case TO_BOOL_STR: + return 1; + case UNARY_INVERT: + return 1; + case UNARY_NEGATIVE: + return 1; + case UNARY_NOT: + return 1; + case UNPACK_EX: + return 1; + case UNPACK_SEQUENCE: + return 1; + case UNPACK_SEQUENCE_LIST: + return 1; + case UNPACK_SEQUENCE_TUPLE: + return 1; + case UNPACK_SEQUENCE_TWO_TUPLE: + return 1; + case WITH_EXCEPT_START: + return 4; + case YIELD_VALUE: + return 1; + default: + return -1; + } +} + +#endif + +extern int _PyOpcode_num_pushed(int opcode, int oparg); +#ifdef NEED_OPCODE_METADATA +int _PyOpcode_num_pushed(int opcode, int oparg) { + switch(opcode) { + case BEFORE_ASYNC_WITH: + return 2; + case BEFORE_WITH: + return 2; + case BINARY_OP: + return 1; + case BINARY_OP_ADD_FLOAT: + return 1; + case BINARY_OP_ADD_INT: + return 1; + case BINARY_OP_ADD_UNICODE: + return 1; + case BINARY_OP_INPLACE_ADD_UNICODE: + return 0; + case BINARY_OP_MULTIPLY_FLOAT: + return 1; + case BINARY_OP_MULTIPLY_INT: + return 1; + case BINARY_OP_SUBTRACT_FLOAT: + return 1; + case BINARY_OP_SUBTRACT_INT: + return 1; + case BINARY_SLICE: + return 1; + case BINARY_SUBSCR: + return 1; + case BINARY_SUBSCR_DICT: + return 1; + case BINARY_SUBSCR_GETITEM: + return 1; + case BINARY_SUBSCR_LIST_INT: + return 1; + case BINARY_SUBSCR_STR_INT: + return 1; + case BINARY_SUBSCR_TUPLE_INT: + return 1; + case BUILD_CONST_KEY_MAP: + return 1; + case BUILD_LIST: + return 1; + case BUILD_MAP: + return 1; + case BUILD_SET: + return 1; + case BUILD_SLICE: + return 1; + case BUILD_STRING: + return 1; + case BUILD_TUPLE: + return 1; + case CACHE: + return 0; + case CALL: + return 1; + case CALL_ALLOC_AND_ENTER_INIT: + return 1; + case CALL_BOUND_METHOD_EXACT_ARGS: + return (((0) ? 1 : 0)); + case CALL_BUILTIN_CLASS: + return 1; + case CALL_BUILTIN_FAST: + return 1; + case CALL_BUILTIN_FAST_WITH_KEYWORDS: + return 1; + case CALL_BUILTIN_O: + return 1; + case CALL_FUNCTION_EX: + return 1; + case CALL_INTRINSIC_1: + return 1; + case CALL_INTRINSIC_2: + return 1; + case CALL_ISINSTANCE: + return 1; + case CALL_KW: + return 1; + case CALL_LEN: + return 1; + case CALL_LIST_APPEND: + return 1; + case CALL_METHOD_DESCRIPTOR_FAST: + return 1; + case CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: + return 1; + case CALL_METHOD_DESCRIPTOR_NOARGS: + return 1; + case CALL_METHOD_DESCRIPTOR_O: + return 1; + case CALL_PY_EXACT_ARGS: + return (((0) ? 1 : 0)); + case CALL_PY_WITH_DEFAULTS: + return 1; + case CALL_STR_1: + return 1; + case CALL_TUPLE_1: + return 1; + case CALL_TYPE_1: + return 1; + case CHECK_EG_MATCH: + return 2; + case CHECK_EXC_MATCH: + return 2; + case CLEANUP_THROW: + return 2; + case COMPARE_OP: + return 1; + case COMPARE_OP_FLOAT: + return 1; + case COMPARE_OP_INT: + return 1; + case COMPARE_OP_STR: + return 1; + case CONTAINS_OP: + return 1; + case CONVERT_VALUE: + return 1; + case COPY: + return 2 + (oparg-1); + case COPY_FREE_VARS: + return 0; + case DELETE_ATTR: + return 0; + case DELETE_DEREF: + return 0; + case DELETE_FAST: + return 0; + case DELETE_GLOBAL: + return 0; + case DELETE_NAME: + return 0; + case DELETE_SUBSCR: + return 0; + case DICT_MERGE: + return 4 + (oparg - 1); + case DICT_UPDATE: + return 1 + (oparg - 1); + case END_ASYNC_FOR: + return 0; + case END_FOR: + return 0; + case END_SEND: + return 1; + case ENTER_EXECUTOR: + return 0; + case EXIT_INIT_CHECK: + return 0; + case EXTENDED_ARG: + return 0; + case FORMAT_SIMPLE: + return 1; + case FORMAT_WITH_SPEC: + return 1; + case FOR_ITER: + return 2; + case FOR_ITER_GEN: + return 2; + case FOR_ITER_LIST: + return 2; + case FOR_ITER_RANGE: + return 2; + case FOR_ITER_TUPLE: + return 2; + case GET_AITER: + return 1; + case GET_ANEXT: + return 2; + case GET_AWAITABLE: + return 1; + case GET_ITER: + return 1; + case GET_LEN: + return 2; + case GET_YIELD_FROM_ITER: + return 1; + case IMPORT_FROM: + return 2; + case IMPORT_NAME: + return 1; + case INSTRUMENTED_CALL: + return 0; + case INSTRUMENTED_CALL_FUNCTION_EX: + return 0; + case INSTRUMENTED_CALL_KW: + return 0; + case INSTRUMENTED_END_FOR: + return 0; + case INSTRUMENTED_END_SEND: + return 1; + case INSTRUMENTED_FOR_ITER: + return 0; + case INSTRUMENTED_INSTRUCTION: + return 0; + case INSTRUMENTED_JUMP_BACKWARD: + return 0; + case INSTRUMENTED_JUMP_FORWARD: + return 0; + case INSTRUMENTED_LOAD_SUPER_ATTR: + return 1 + ((oparg & 1)); + case INSTRUMENTED_POP_JUMP_IF_FALSE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_NONE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_NOT_NONE: + return 0; + case INSTRUMENTED_POP_JUMP_IF_TRUE: + return 0; + case INSTRUMENTED_RESUME: + return 0; + case INSTRUMENTED_RETURN_CONST: + return 0; + case INSTRUMENTED_RETURN_VALUE: + return 0; + case INSTRUMENTED_YIELD_VALUE: + return 1; + case INTERPRETER_EXIT: + return 0; + case IS_OP: + return 1; + case JUMP_BACKWARD: + return 0; + case JUMP_BACKWARD_NO_INTERRUPT: + return 0; + case JUMP_FORWARD: + return 0; + case LIST_APPEND: + return 1 + (oparg-1); + case LIST_EXTEND: + return 1 + (oparg-1); + case LOAD_ASSERTION_ERROR: + return 1; + case LOAD_ATTR: + return 1 + ((oparg & 1)); + case LOAD_ATTR_CLASS: + return 1 + ((oparg & 1)); + case LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN: + return 1 + (((0) ? 1 : 0)); + case LOAD_ATTR_INSTANCE_VALUE: + return 1 + ((oparg & 1)); + case LOAD_ATTR_METHOD_LAZY_DICT: + return 1 + (((1) ? 1 : 0)); + case LOAD_ATTR_METHOD_NO_DICT: + return 1 + (((1) ? 1 : 0)); + case LOAD_ATTR_METHOD_WITH_VALUES: + return 1 + (((1) ? 1 : 0)); + case LOAD_ATTR_MODULE: + return 1 + ((oparg & 1)); + case LOAD_ATTR_NONDESCRIPTOR_NO_DICT: + return 1 + (((0) ? 1 : 0)); + case LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: + return 1 + (((0) ? 1 : 0)); + case LOAD_ATTR_PROPERTY: + return 1 + (((0) ? 1 : 0)); + case LOAD_ATTR_SLOT: + return 1 + ((oparg & 1)); + case LOAD_ATTR_WITH_HINT: + return 1 + ((oparg & 1)); + case LOAD_BUILD_CLASS: + return 1; + case LOAD_CONST: + return 1; + case LOAD_DEREF: + return 1; + case LOAD_FAST: + return 1; + case LOAD_FAST_AND_CLEAR: + return 1; + case LOAD_FAST_CHECK: + return 1; + case LOAD_FAST_LOAD_FAST: + return 2; + case LOAD_FROM_DICT_OR_DEREF: + return 1; + case LOAD_FROM_DICT_OR_GLOBALS: + return 1; + case LOAD_GLOBAL: + return 1 + ((oparg & 1)); + case LOAD_GLOBAL_BUILTIN: + return 1 + ((oparg & 1)); + case LOAD_GLOBAL_MODULE: + return 1 + ((oparg & 1)); + case LOAD_LOCALS: + return 1; + case LOAD_NAME: + return 1; + case LOAD_SUPER_ATTR: + return 1 + ((oparg & 1)); + case LOAD_SUPER_ATTR_ATTR: + return 1 + (((0) ? 1 : 0)); + case LOAD_SUPER_ATTR_METHOD: + return 2; + case MAKE_CELL: + return 0; + case MAKE_FUNCTION: + return 1; + case MAP_ADD: + return 1 + (oparg - 1); + case MATCH_CLASS: + return 1; + case MATCH_KEYS: + return 3; + case MATCH_MAPPING: + return 2; + case MATCH_SEQUENCE: + return 2; + case NOP: + return 0; + case POP_EXCEPT: + return 0; + case POP_JUMP_IF_FALSE: + return 0; + case POP_JUMP_IF_NONE: + return 0; + case POP_JUMP_IF_NOT_NONE: + return 0; + case POP_JUMP_IF_TRUE: + return 0; + case POP_TOP: + return 0; + case PUSH_EXC_INFO: + return 2; + case PUSH_NULL: + return 1; + case RAISE_VARARGS: + return 0; + case RERAISE: + return oparg; + case RESERVED: + return 0; + case RESUME: + return 0; + case RESUME_CHECK: + return 0; + case RETURN_CONST: + return 0; + case RETURN_GENERATOR: + return 0; + case RETURN_VALUE: + return 0; + case SEND: + return 2; + case SEND_GEN: + return 2; + case SETUP_ANNOTATIONS: + return 0; + case SET_ADD: + return 1 + (oparg-1); + case SET_FUNCTION_ATTRIBUTE: + return 1; + case SET_UPDATE: + return 1 + (oparg-1); + case STORE_ATTR: + return 0; + case STORE_ATTR_INSTANCE_VALUE: + return 0; + case STORE_ATTR_SLOT: + return 0; + case STORE_ATTR_WITH_HINT: + return 0; + case STORE_DEREF: + return 0; + case STORE_FAST: + return 0; + case STORE_FAST_LOAD_FAST: + return 1; + case STORE_FAST_STORE_FAST: + return 0; + case STORE_GLOBAL: + return 0; + case STORE_NAME: + return 0; + case STORE_SLICE: + return 0; + case STORE_SUBSCR: + return 0; + case STORE_SUBSCR_DICT: + return 0; + case STORE_SUBSCR_LIST_INT: + return 0; + case SWAP: + return 2 + (oparg-2); + case TO_BOOL: + return 1; + case TO_BOOL_ALWAYS_TRUE: + return 1; + case TO_BOOL_BOOL: + return 1; + case TO_BOOL_INT: + return 1; + case TO_BOOL_LIST: + return 1; + case TO_BOOL_NONE: + return 1; + case TO_BOOL_STR: + return 1; + case UNARY_INVERT: + return 1; + case UNARY_NEGATIVE: + return 1; + case UNARY_NOT: + return 1; + case UNPACK_EX: + return 1 + (oparg >> 8) + (oparg & 0xFF); + case UNPACK_SEQUENCE: + return oparg; + case UNPACK_SEQUENCE_LIST: + return oparg; + case UNPACK_SEQUENCE_TUPLE: + return oparg; + case UNPACK_SEQUENCE_TWO_TUPLE: + return oparg; + case WITH_EXCEPT_START: + return 5; + case YIELD_VALUE: + return 1; + default: + return -1; + } +} + +#endif + enum InstructionFormat { INSTR_FMT_IB = 1, INSTR_FMT_IBC = 2, diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index feef5b4b4d950c..f493e600ef8604 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -23,6 +23,7 @@ ) from cwriter import CWriter from typing import TextIO +from stack import get_stack_effect # Constants used instead of size for macro expansions. # Note: 1, 2, 4 must match actual cache entry sizes. @@ -59,6 +60,39 @@ def generate_flag_macros(out: CWriter) -> None: out.emit(f"#define OPCODE_HAS_{flag}(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_{flag}_FLAG))\n") +def emit_stack_effect_function( + out: CWriter, direction: str, data: list[tuple[str, str]] +) -> None: + out.emit(f"extern int _PyOpcode_num_{direction}(int opcode, int oparg);\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") + out.emit(f"int _PyOpcode_num_{direction}(int opcode, int oparg) {{\n") + out.emit("switch(opcode) {\n") + for name, effect in data: + out.emit(f"case {name}:\n") + out.emit(f" return {effect};\n") + out.emit("default:\n") + out.emit(" return -1;\n") + out.emit("}\n") + out.emit("}\n\n") + out.emit("#endif\n\n") + + +def generate_stack_effect_functions( + analysis: Analysis, out: CWriter +) -> None: + + popped_data: list[tuple[str, str]] = [] + pushed_data: list[tuple[str, str]] = [] + for inst in analysis.instructions.values(): + stack = get_stack_effect(inst) + popped = (-stack.base_offset).to_c() + pushed = (stack.top_offset - stack.base_offset).to_c() + popped_data.append((inst.name, popped)) + pushed_data.append((inst.name, pushed)) + emit_stack_effect_function(out, "popped", sorted(popped_data)) + emit_stack_effect_function(out, "pushed", sorted(pushed_data)) + + def generate_is_pseudo( analysis: Analysis, out: CWriter ) -> None: @@ -260,6 +294,7 @@ def generate_opcode_metadata( out.emit('#include "opcode_ids.h"\n') generate_is_pseudo(analysis, out) out.emit('#include "pycore_uop_ids.h"\n') + generate_stack_effect_functions(analysis, out) generate_instruction_formats(analysis, out) out.emit("#define IS_VALID_OPCODE(OP) \\\n") out.emit(" (((OP) >= 0) && ((OP) < 256) && \\\n") diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index c36a56ebf2d381..9491d7ff303500 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -1,5 +1,5 @@ import sys -from analyzer import StackItem +from analyzer import StackItem, Instruction, Uop from dataclasses import dataclass from formatting import maybe_parenthesize from cwriter import CWriter @@ -29,6 +29,18 @@ def pop(self, item: StackItem) -> None: def push(self, item: StackItem) -> None: self.pushed.append(var_size(item)) + def __sub__(self, other:"StackOffset") -> "StackOffset": + res = StackOffset() + res.popped = self.popped + other.pushed + res.pushed = self.pushed + other.popped + return res + + def __neg__(self) -> "StackOffset": + res = StackOffset() + res.popped = self.pushed + res.pushed = self.popped + return res + def simplify(self) -> None: "Remove matching values from both the popped and pushed list" if not self.popped or not self.pushed: @@ -166,3 +178,14 @@ def flush(self, out: CWriter) -> None: def as_comment(self) -> str: return f"/* Variables: {[v.name for v in self.variables]}. Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" + +def get_stack_effect(inst: Instruction) -> Stack: + stack = Stack() + for uop in inst.parts: + if not isinstance(uop, Uop): + continue + for var in reversed(uop.stack.inputs): + stack.pop(var) + for i, var in enumerate(uop.stack.outputs): + stack.push(var) + return stack \ No newline at end of file From 2bbae3ff97b4c6926e6d85463640848f188a1e37 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 06:51:20 +0000 Subject: [PATCH 19/51] Add OPARG macros --- Include/internal/pycore_opcode_metadata.h | 9 +++++++++ Tools/cases_generator/opcode_metadata_generator.py | 8 ++++++++ 2 files changed, 17 insertions(+) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index a4c157a43e781c..7a5355525b8554 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -919,6 +919,15 @@ enum InstructionFormat { #define OPCODE_HAS_DEOPT(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_DEOPT_FLAG)) #define OPCODE_HAS_ERROR(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ERROR_FLAG)) #define OPCODE_HAS_ESCAPES(OP) (_PyOpcode_opcode_metadata[OP].flags & (HAS_ESCAPES_FLAG)) + +#define OPARG_FULL 0 +#define OPARG_CACHE_1 1 +#define OPARG_CACHE_2 2 +#define OPARG_CACHE_4 4 +#define OPARG_TOP 5 +#define OPARG_BOTTOM 6 +#define OPARG_SAVE_RETURN_OFFSET 7 + struct opcode_metadata { uint8_t valid_entry; uint8_t instr_format; diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index f493e600ef8604..14c678ac8fb1a1 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -58,6 +58,13 @@ def generate_flag_macros(out: CWriter) -> None: out.emit(f"#define HAS_{flag}_FLAG ({1< None: + for name, value in OPARG_SIZES.items(): + out.emit(f"#define {name} {value}\n") + out.emit("\n") def emit_stack_effect_function( @@ -300,6 +307,7 @@ def generate_opcode_metadata( out.emit(" (((OP) >= 0) && ((OP) < 256) && \\\n") out.emit(" (_PyOpcode_opcode_metadata[(OP)].valid_entry))\n\n") generate_flag_macros(out) + generate_oparg_macros(out) generate_metadata_table(analysis, out) generate_expansion_table(analysis, out) generate_name_table(analysis, out) From f0b96a841ef33318119c06b721301db9a994e3ad Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 06:57:52 +0000 Subject: [PATCH 20/51] Fixes --- Include/internal/pycore_opcode_metadata.h | 9 ++++++--- Tools/cases_generator/opcode_metadata_generator.py | 10 ++++++---- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 7a5355525b8554..e37164a0f2a265 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -934,6 +934,8 @@ struct opcode_metadata { uint16_t flags; }; +extern const struct opcode_metadata _PyOpcode_opcode_metadata[256]; +#ifdef NEED_OPCODE_METADATA const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [BEFORE_ASYNC_WITH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BEFORE_WITH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1143,13 +1145,14 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, }; +#endif #define MAX_UOP_PER_EXPANSION 8 struct opcode_macro_expansion { - int nuops;struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION]; + int nuops; + struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION]; }; -extern const struct opcode_macro_expansion -_PyOpcode_macro_expansion[256]; +extern const struct opcode_macro_expansion _PyOpcode_macro_expansion[256]; #ifdef NEED_OPCODE_METADATA const struct opcode_macro_expansion diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 14c678ac8fb1a1..7776054acc8d10 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -186,10 +186,13 @@ def generate_metadata_table( out.emit("uint8_t instr_format;\n"); out.emit("uint16_t flags;\n"); out.emit("};\n\n") + out.emit("extern const struct opcode_metadata _PyOpcode_opcode_metadata[256];\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const struct opcode_metadata _PyOpcode_opcode_metadata[256] = {\n") for inst in sorted(analysis.instructions.values(), key = lambda t:t.name): out.emit(f"[{inst.name}] = {{ true, {get_format(inst)}, {cflags(inst.properties)} }},\n") - out.emit("};\n\n") + out.emit("};\n") + out.emit("#endif\n\n") def generate_expansion_table( analysis: Analysis, out: CWriter @@ -225,11 +228,10 @@ def generate_expansion_table( max_uops = max (len(ex) for ex in expansions_table.values()) out.emit(f"#define MAX_UOP_PER_EXPANSION {max_uops}\n") out.emit("struct opcode_macro_expansion {\n") - out.emit("int nuops;") + out.emit("int nuops;\n") out.emit("struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION];\n") out.emit("};\n") - out.emit("extern const struct opcode_macro_expansion\n") - out.emit("_PyOpcode_macro_expansion[256];\n\n") + out.emit("extern const struct opcode_macro_expansion _PyOpcode_macro_expansion[256];\n\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const struct opcode_macro_expansion\n") out.emit("_PyOpcode_macro_expansion[256] = {\n") From 31d1333a1aefb5b3d823c98cc8b837a7711a692b Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 07:01:57 +0000 Subject: [PATCH 21/51] Tidy up stack_effect function --- Python/compile.c | 29 +++-------------------------- 1 file changed, 3 insertions(+), 26 deletions(-) diff --git a/Python/compile.c b/Python/compile.c index dad2d37525e750..65ac05ad58d4dd 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -796,35 +796,12 @@ stack_effect(int opcode, int oparg, int jump) // Specialized instructions are not supported. return PY_INVALID_STACK_EFFECT; } - int popped, pushed; - if (jump > 0) { - popped = _PyOpcode_num_popped(opcode, oparg, true); - pushed = _PyOpcode_num_pushed(opcode, oparg, true); - } - else { - popped = _PyOpcode_num_popped(opcode, oparg, false); - pushed = _PyOpcode_num_pushed(opcode, oparg, false); - } + int popped = _PyOpcode_num_popped(opcode, oparg); + int pushed = _PyOpcode_num_pushed(opcode, oparg); if (popped < 0 || pushed < 0) { return PY_INVALID_STACK_EFFECT; } - if (jump >= 0) { - return pushed - popped; - } - if (jump < 0) { - // Compute max(pushed - popped, alt_pushed - alt_popped) - int alt_popped = _PyOpcode_num_popped(opcode, oparg, true); - int alt_pushed = _PyOpcode_num_pushed(opcode, oparg, true); - if (alt_popped < 0 || alt_pushed < 0) { - return PY_INVALID_STACK_EFFECT; - } - int diff = pushed - popped; - int alt_diff = alt_pushed - alt_popped; - if (alt_diff > diff) { - return alt_diff; - } - return diff; - } + return pushed - popped; } // Pseudo ops From d8c973a52c557a868db6a659ba56f0e4f33bebbe Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 07:19:51 +0000 Subject: [PATCH 22/51] Exclude tier1-only from uop expansions --- Include/internal/pycore_opcode_metadata.h | 13 ------------- Tools/cases_generator/opcode_metadata_generator.py | 5 +++-- 2 files changed, 3 insertions(+), 15 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index e37164a0f2a265..1063bd39362d0b 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1162,7 +1162,6 @@ _PyOpcode_macro_expansion[256] = { [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_ADD_FLOAT, 0, 0 } } }, [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_ADD_INT, 0, 0 } } }, [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_ADD_UNICODE, 0, 0 } } }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_INPLACE_ADD_UNICODE, 0, 0 } } }, [BINARY_OP_MULTIPLY_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_MULTIPLY_FLOAT, 0, 0 } } }, [BINARY_OP_MULTIPLY_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_MULTIPLY_INT, 0, 0 } } }, [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, 0, 0 } } }, @@ -1179,7 +1178,6 @@ _PyOpcode_macro_expansion[256] = { [BUILD_SLICE] = { .nuops = 1, .uops = { { _BUILD_SLICE, 0, 0 } } }, [BUILD_STRING] = { .nuops = 1, .uops = { { _BUILD_STRING, 0, 0 } } }, [BUILD_TUPLE] = { .nuops = 1, .uops = { { _BUILD_TUPLE, 0, 0 } } }, - [CACHE] = { .nuops = 1, .uops = { { _CACHE, 0, 0 } } }, [CALL_BOUND_METHOD_EXACT_ARGS] = { .nuops = 8, .uops = { { _CHECK_PEP_523, 0, 0 }, { _CHECK_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _INIT_CALL_BOUND_METHOD_EXACT_ARGS, 0, 0 }, { _CHECK_FUNCTION_EXACT_ARGS, 2, 1 }, { _CHECK_STACK_SPACE, 0, 0 }, { _INIT_CALL_PY_EXACT_ARGS, 0, 0 }, { _SAVE_RETURN_OFFSET, 7, 3 }, { _PUSH_FRAME, 0, 0 } } }, [CALL_BUILTIN_CLASS] = { .nuops = 1, .uops = { { _CALL_BUILTIN_CLASS, 3, 0 } } }, [CALL_BUILTIN_FAST] = { .nuops = 1, .uops = { { _CALL_BUILTIN_FAST, 3, 0 } } }, @@ -1189,7 +1187,6 @@ _PyOpcode_macro_expansion[256] = { [CALL_INTRINSIC_2] = { .nuops = 1, .uops = { { _CALL_INTRINSIC_2, 0, 0 } } }, [CALL_ISINSTANCE] = { .nuops = 1, .uops = { { _CALL_ISINSTANCE, 3, 0 } } }, [CALL_LEN] = { .nuops = 1, .uops = { { _CALL_LEN, 3, 0 } } }, - [CALL_LIST_APPEND] = { .nuops = 1, .uops = { { _CALL_LIST_APPEND, 3, 0 } } }, [CALL_METHOD_DESCRIPTOR_FAST] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST, 3, 0 } } }, [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, 3, 0 } } }, [CALL_METHOD_DESCRIPTOR_NOARGS] = { .nuops = 1, .uops = { { _CALL_METHOD_DESCRIPTOR_NOARGS, 3, 0 } } }, @@ -1217,9 +1214,7 @@ _PyOpcode_macro_expansion[256] = { [DICT_UPDATE] = { .nuops = 1, .uops = { { _DICT_UPDATE, 0, 0 } } }, [END_FOR] = { .nuops = 2, .uops = { { _POP_TOP, 0, 0 }, { _POP_TOP, 0, 0 } } }, [END_SEND] = { .nuops = 1, .uops = { { _END_SEND, 0, 0 } } }, - [ENTER_EXECUTOR] = { .nuops = 1, .uops = { { _ENTER_EXECUTOR, 0, 0 } } }, [EXIT_INIT_CHECK] = { .nuops = 1, .uops = { { _EXIT_INIT_CHECK, 0, 0 } } }, - [EXTENDED_ARG] = { .nuops = 1, .uops = { { _EXTENDED_ARG, 0, 0 } } }, [FORMAT_SIMPLE] = { .nuops = 1, .uops = { { _FORMAT_SIMPLE, 0, 0 } } }, [FORMAT_WITH_SPEC] = { .nuops = 1, .uops = { { _FORMAT_WITH_SPEC, 0, 0 } } }, [GET_AITER] = { .nuops = 1, .uops = { { _GET_AITER, 0, 0 } } }, @@ -1228,12 +1223,7 @@ _PyOpcode_macro_expansion[256] = { [GET_ITER] = { .nuops = 1, .uops = { { _GET_ITER, 0, 0 } } }, [GET_LEN] = { .nuops = 1, .uops = { { _GET_LEN, 0, 0 } } }, [GET_YIELD_FROM_ITER] = { .nuops = 1, .uops = { { _GET_YIELD_FROM_ITER, 0, 0 } } }, - [IMPORT_FROM] = { .nuops = 1, .uops = { { _IMPORT_FROM, 0, 0 } } }, - [IMPORT_NAME] = { .nuops = 1, .uops = { { _IMPORT_NAME, 0, 0 } } }, - [INTERPRETER_EXIT] = { .nuops = 1, .uops = { { _INTERPRETER_EXIT, 0, 0 } } }, [IS_OP] = { .nuops = 1, .uops = { { _IS_OP, 0, 0 } } }, - [JUMP_BACKWARD_NO_INTERRUPT] = { .nuops = 1, .uops = { { _JUMP_BACKWARD_NO_INTERRUPT, 0, 0 } } }, - [JUMP_FORWARD] = { .nuops = 1, .uops = { { _JUMP_FORWARD, 0, 0 } } }, [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND, 0, 0 } } }, [LIST_EXTEND] = { .nuops = 1, .uops = { { _LIST_EXTEND, 0, 0 } } }, [LOAD_ASSERTION_ERROR] = { .nuops = 1, .uops = { { _LOAD_ASSERTION_ERROR, 0, 0 } } }, @@ -1274,10 +1264,8 @@ _PyOpcode_macro_expansion[256] = { [POP_TOP] = { .nuops = 1, .uops = { { _POP_TOP, 0, 0 } } }, [PUSH_EXC_INFO] = { .nuops = 1, .uops = { { _PUSH_EXC_INFO, 0, 0 } } }, [PUSH_NULL] = { .nuops = 1, .uops = { { _PUSH_NULL, 0, 0 } } }, - [RESERVED] = { .nuops = 1, .uops = { { _RESERVED, 0, 0 } } }, [RESUME_CHECK] = { .nuops = 1, .uops = { { _RESUME_CHECK, 0, 0 } } }, [RETURN_CONST] = { .nuops = 2, .uops = { { _LOAD_CONST, 0, 0 }, { _POP_FRAME, 0, 0 } } }, - [RETURN_GENERATOR] = { .nuops = 1, .uops = { { _RETURN_GENERATOR, 0, 0 } } }, [RETURN_VALUE] = { .nuops = 1, .uops = { { _POP_FRAME, 0, 0 } } }, [SETUP_ANNOTATIONS] = { .nuops = 1, .uops = { { _SETUP_ANNOTATIONS, 0, 0 } } }, [SET_ADD] = { .nuops = 1, .uops = { { _SET_ADD, 0, 0 } } }, @@ -1309,7 +1297,6 @@ _PyOpcode_macro_expansion[256] = { [UNPACK_SEQUENCE_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TUPLE, 1, 0 } } }, [UNPACK_SEQUENCE_TWO_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TWO_TUPLE, 1, 0 } } }, [WITH_EXCEPT_START] = { .nuops = 1, .uops = { { _WITH_EXCEPT_START, 0, 0 } } }, - [YIELD_VALUE] = { .nuops = 1, .uops = { { _YIELD_VALUE, 0, 0 } } }, }; #endif // NEED_OPCODE_METADATA diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 7776054acc8d10..309b0552e21902 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -244,8 +244,9 @@ def generate_expansion_table( def is_viable_expansion(inst: Instruction) -> bool: "An instruction can be expanded if all its parts are viable for tier 2" for part in inst.parts: - if isinstance(part, Uop) and not part.is_viable(): - return False + if isinstance(part, Uop): + if part.properties.tier_one_only or not part.is_viable(): + return False return True From e35318137b8fba0c2128b39071510e167d66d075 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 08:13:37 +0000 Subject: [PATCH 23/51] More fixes --- Include/internal/pycore_opcode_metadata.h | 14 +- Include/internal/pycore_uop_ids.h | 191 ++++++++---------- Include/internal/pycore_uop_metadata.h | 69 ------- Python/optimizer.c | 7 +- .../opcode_metadata_generator.py | 18 +- Tools/cases_generator/uop_id_generator.py | 8 +- .../cases_generator/uop_metadata_generator.py | 6 +- 7 files changed, 113 insertions(+), 200 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 1063bd39362d0b..10115f0adfc6fa 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1300,6 +1300,8 @@ _PyOpcode_macro_expansion[256] = { }; #endif // NEED_OPCODE_METADATA +extern const char *_PyOpcode_OpName[268]; +#ifdef NEED_OPCODE_METADATA const char *_PyOpcode_OpName[268] = { [BEFORE_ASYNC_WITH] = "BEFORE_ASYNC_WITH", [BEFORE_WITH] = "BEFORE_WITH", @@ -1522,7 +1524,10 @@ const char *_PyOpcode_OpName[268] = { [WITH_EXCEPT_START] = "WITH_EXCEPT_START", [YIELD_VALUE] = "YIELD_VALUE", }; +#endif +extern const uint8_t _PyOpcode_Caches[256]; +#ifdef NEED_OPCODE_METADATA const uint8_t _PyOpcode_Caches[256] = { [TO_BOOL_BOOL] = 3, [TO_BOOL_INT] = 3, @@ -1620,6 +1625,7 @@ const uint8_t _PyOpcode_Caches[256] = { [CALL_PY_EXACT_ARGS] = 3, [BINARY_OP] = 1, }; +#endif extern const uint8_t _PyOpcode_Deopt[256]; #ifdef NEED_OPCODE_METADATA @@ -1889,9 +1895,9 @@ const uint8_t _PyOpcode_Deopt[256] = { struct pseudo_targets { uint8_t targets[3]; }; -const struct pseudo_targets pseudo_targets[12]; +extern const struct pseudo_targets _PyOpcode_PseudoTargets[12]; #ifdef NEED_OPCODE_METADATA -const struct pseudo_targets pseudo_targets[12] = { +const struct pseudo_targets _PyOpcode_PseudoTargets[12] = { [LOAD_CLOSURE-256] = { { LOAD_FAST, 0, 0 } }, [STORE_FAST_MAYBE_NULL-256] = { { STORE_FAST, 0, 0 } }, [LOAD_SUPER_METHOD-256] = { { LOAD_SUPER_ATTR, 0, 0 } }, @@ -1912,8 +1918,8 @@ is_pseudo_target(int pseudo, int target) { if (pseudo < 256 || pseudo >= 268) { return false; } - for (int i = 0; pseudo_targets[pseudo-256].targets[i]; i++) { - if (pseudo_targets[pseudo-256].targets[i] == target) return true; + for (int i = 0; _PyOpcode_PseudoTargets[pseudo-256].targets[i]; i++) { + if (_PyOpcode_PseudoTargets[pseudo-256].targets[i] == target) return true; } return false; } diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index c6b0d4b912a9d4..4a9a00ba352d33 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -12,7 +12,6 @@ extern "C" { #define _EXIT_TRACE 300 #define _SET_IP 301 #define _NOP NOP -#define _RESUME RESUME #define _RESUME_CHECK RESUME_CHECK #define _INSTRUMENTED_RESUME INSTRUMENTED_RESUME #define _LOAD_FAST_CHECK LOAD_FAST_CHECK @@ -25,13 +24,10 @@ extern "C" { #define _STORE_FAST_STORE_FAST STORE_FAST_STORE_FAST #define _POP_TOP POP_TOP #define _PUSH_NULL PUSH_NULL -#define _INSTRUMENTED_END_FOR INSTRUMENTED_END_FOR #define _END_SEND END_SEND -#define _INSTRUMENTED_END_SEND INSTRUMENTED_END_SEND #define _UNARY_NEGATIVE UNARY_NEGATIVE #define _UNARY_NOT UNARY_NOT -#define _SPECIALIZE_TO_BOOL 302 -#define _TO_BOOL 303 +#define _TO_BOOL 302 #define _TO_BOOL_BOOL TO_BOOL_BOOL #define _TO_BOOL_INT TO_BOOL_INT #define _TO_BOOL_LIST TO_BOOL_LIST @@ -39,19 +35,17 @@ extern "C" { #define _TO_BOOL_STR TO_BOOL_STR #define _TO_BOOL_ALWAYS_TRUE TO_BOOL_ALWAYS_TRUE #define _UNARY_INVERT UNARY_INVERT -#define _GUARD_BOTH_INT 304 -#define _BINARY_OP_MULTIPLY_INT 305 -#define _BINARY_OP_ADD_INT 306 -#define _BINARY_OP_SUBTRACT_INT 307 -#define _GUARD_BOTH_FLOAT 308 -#define _BINARY_OP_MULTIPLY_FLOAT 309 -#define _BINARY_OP_ADD_FLOAT 310 -#define _BINARY_OP_SUBTRACT_FLOAT 311 -#define _GUARD_BOTH_UNICODE 312 -#define _BINARY_OP_ADD_UNICODE 313 -#define _BINARY_OP_INPLACE_ADD_UNICODE 314 -#define _SPECIALIZE_BINARY_SUBSCR 315 -#define _BINARY_SUBSCR 316 +#define _GUARD_BOTH_INT 303 +#define _BINARY_OP_MULTIPLY_INT 304 +#define _BINARY_OP_ADD_INT 305 +#define _BINARY_OP_SUBTRACT_INT 306 +#define _GUARD_BOTH_FLOAT 307 +#define _BINARY_OP_MULTIPLY_FLOAT 308 +#define _BINARY_OP_ADD_FLOAT 309 +#define _BINARY_OP_SUBTRACT_FLOAT 310 +#define _GUARD_BOTH_UNICODE 311 +#define _BINARY_OP_ADD_UNICODE 312 +#define _BINARY_SUBSCR 313 #define _BINARY_SLICE BINARY_SLICE #define _STORE_SLICE STORE_SLICE #define _BINARY_SUBSCR_LIST_INT BINARY_SUBSCR_LIST_INT @@ -61,54 +55,43 @@ extern "C" { #define _BINARY_SUBSCR_GETITEM BINARY_SUBSCR_GETITEM #define _LIST_APPEND LIST_APPEND #define _SET_ADD SET_ADD -#define _SPECIALIZE_STORE_SUBSCR 317 -#define _STORE_SUBSCR 318 +#define _STORE_SUBSCR 314 #define _STORE_SUBSCR_LIST_INT STORE_SUBSCR_LIST_INT #define _STORE_SUBSCR_DICT STORE_SUBSCR_DICT #define _DELETE_SUBSCR DELETE_SUBSCR #define _CALL_INTRINSIC_1 CALL_INTRINSIC_1 #define _CALL_INTRINSIC_2 CALL_INTRINSIC_2 -#define _RAISE_VARARGS RAISE_VARARGS -#define _INTERPRETER_EXIT INTERPRETER_EXIT -#define _POP_FRAME 319 +#define _POP_FRAME 315 #define _INSTRUMENTED_RETURN_VALUE INSTRUMENTED_RETURN_VALUE #define _INSTRUMENTED_RETURN_CONST INSTRUMENTED_RETURN_CONST #define _GET_AITER GET_AITER #define _GET_ANEXT GET_ANEXT #define _GET_AWAITABLE GET_AWAITABLE -#define _SPECIALIZE_SEND 320 -#define _SEND 321 +#define _SEND 316 #define _SEND_GEN SEND_GEN #define _INSTRUMENTED_YIELD_VALUE INSTRUMENTED_YIELD_VALUE -#define _YIELD_VALUE YIELD_VALUE #define _POP_EXCEPT POP_EXCEPT -#define _RERAISE RERAISE -#define _END_ASYNC_FOR END_ASYNC_FOR -#define _CLEANUP_THROW CLEANUP_THROW #define _LOAD_ASSERTION_ERROR LOAD_ASSERTION_ERROR #define _LOAD_BUILD_CLASS LOAD_BUILD_CLASS #define _STORE_NAME STORE_NAME #define _DELETE_NAME DELETE_NAME -#define _SPECIALIZE_UNPACK_SEQUENCE 322 -#define _UNPACK_SEQUENCE 323 +#define _UNPACK_SEQUENCE 317 #define _UNPACK_SEQUENCE_TWO_TUPLE UNPACK_SEQUENCE_TWO_TUPLE #define _UNPACK_SEQUENCE_TUPLE UNPACK_SEQUENCE_TUPLE #define _UNPACK_SEQUENCE_LIST UNPACK_SEQUENCE_LIST #define _UNPACK_EX UNPACK_EX -#define _SPECIALIZE_STORE_ATTR 324 -#define _STORE_ATTR 325 +#define _STORE_ATTR 318 #define _DELETE_ATTR DELETE_ATTR #define _STORE_GLOBAL STORE_GLOBAL #define _DELETE_GLOBAL DELETE_GLOBAL #define _LOAD_LOCALS LOAD_LOCALS #define _LOAD_FROM_DICT_OR_GLOBALS LOAD_FROM_DICT_OR_GLOBALS #define _LOAD_NAME LOAD_NAME -#define _SPECIALIZE_LOAD_GLOBAL 326 -#define _LOAD_GLOBAL 327 -#define _GUARD_GLOBALS_VERSION 328 -#define _GUARD_BUILTINS_VERSION 329 -#define _LOAD_GLOBAL_MODULE 330 -#define _LOAD_GLOBAL_BUILTINS 331 +#define _LOAD_GLOBAL 319 +#define _GUARD_GLOBALS_VERSION 320 +#define _GUARD_BUILTINS_VERSION 321 +#define _LOAD_GLOBAL_MODULE 322 +#define _LOAD_GLOBAL_BUILTINS 323 #define _DELETE_FAST DELETE_FAST #define _MAKE_CELL MAKE_CELL #define _DELETE_DEREF DELETE_DEREF @@ -129,30 +112,26 @@ extern "C" { #define _DICT_MERGE DICT_MERGE #define _MAP_ADD MAP_ADD #define _INSTRUMENTED_LOAD_SUPER_ATTR INSTRUMENTED_LOAD_SUPER_ATTR -#define _SPECIALIZE_LOAD_SUPER_ATTR 332 -#define _LOAD_SUPER_ATTR 333 #define _LOAD_SUPER_ATTR_ATTR LOAD_SUPER_ATTR_ATTR #define _LOAD_SUPER_ATTR_METHOD LOAD_SUPER_ATTR_METHOD -#define _SPECIALIZE_LOAD_ATTR 334 -#define _LOAD_ATTR 335 -#define _GUARD_TYPE_VERSION 336 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES 337 -#define _LOAD_ATTR_INSTANCE_VALUE 338 -#define _CHECK_ATTR_MODULE 339 -#define _LOAD_ATTR_MODULE 340 -#define _CHECK_ATTR_WITH_HINT 341 -#define _LOAD_ATTR_WITH_HINT 342 -#define _LOAD_ATTR_SLOT 343 -#define _CHECK_ATTR_CLASS 344 -#define _LOAD_ATTR_CLASS 345 +#define _LOAD_ATTR 324 +#define _GUARD_TYPE_VERSION 325 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES 326 +#define _LOAD_ATTR_INSTANCE_VALUE 327 +#define _CHECK_ATTR_MODULE 328 +#define _LOAD_ATTR_MODULE 329 +#define _CHECK_ATTR_WITH_HINT 330 +#define _LOAD_ATTR_WITH_HINT 331 +#define _LOAD_ATTR_SLOT 332 +#define _CHECK_ATTR_CLASS 333 +#define _LOAD_ATTR_CLASS 334 #define _LOAD_ATTR_PROPERTY LOAD_ATTR_PROPERTY #define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN -#define _GUARD_DORV_VALUES 346 -#define _STORE_ATTR_INSTANCE_VALUE 347 +#define _GUARD_DORV_VALUES 335 +#define _STORE_ATTR_INSTANCE_VALUE 336 #define _STORE_ATTR_WITH_HINT STORE_ATTR_WITH_HINT -#define _STORE_ATTR_SLOT 348 -#define _SPECIALIZE_COMPARE_OP 349 -#define _COMPARE_OP 350 +#define _STORE_ATTR_SLOT 337 +#define _COMPARE_OP 338 #define _COMPARE_OP_FLOAT COMPARE_OP_FLOAT #define _COMPARE_OP_INT COMPARE_OP_INT #define _COMPARE_OP_STR COMPARE_OP_STR @@ -160,15 +139,10 @@ extern "C" { #define _CONTAINS_OP CONTAINS_OP #define _CHECK_EG_MATCH CHECK_EG_MATCH #define _CHECK_EXC_MATCH CHECK_EXC_MATCH -#define _IMPORT_NAME IMPORT_NAME -#define _IMPORT_FROM IMPORT_FROM -#define _JUMP_FORWARD JUMP_FORWARD #define _JUMP_BACKWARD JUMP_BACKWARD -#define _ENTER_EXECUTOR ENTER_EXECUTOR -#define _POP_JUMP_IF_FALSE 351 -#define _POP_JUMP_IF_TRUE 352 -#define _IS_NONE 353 -#define _JUMP_BACKWARD_NO_INTERRUPT JUMP_BACKWARD_NO_INTERRUPT +#define _POP_JUMP_IF_FALSE 339 +#define _POP_JUMP_IF_TRUE 340 +#define _IS_NONE 341 #define _GET_LEN GET_LEN #define _MATCH_CLASS MATCH_CLASS #define _MATCH_MAPPING MATCH_MAPPING @@ -176,45 +150,43 @@ extern "C" { #define _MATCH_KEYS MATCH_KEYS #define _GET_ITER GET_ITER #define _GET_YIELD_FROM_ITER GET_YIELD_FROM_ITER -#define _SPECIALIZE_FOR_ITER 354 -#define _FOR_ITER 355 -#define _FOR_ITER_TIER_TWO 356 +#define _FOR_ITER 342 +#define _FOR_ITER_TIER_TWO 343 #define _INSTRUMENTED_FOR_ITER INSTRUMENTED_FOR_ITER -#define _ITER_CHECK_LIST 357 -#define _ITER_JUMP_LIST 358 -#define _GUARD_NOT_EXHAUSTED_LIST 359 -#define _ITER_NEXT_LIST 360 -#define _ITER_CHECK_TUPLE 361 -#define _ITER_JUMP_TUPLE 362 -#define _GUARD_NOT_EXHAUSTED_TUPLE 363 -#define _ITER_NEXT_TUPLE 364 -#define _ITER_CHECK_RANGE 365 -#define _ITER_JUMP_RANGE 366 -#define _GUARD_NOT_EXHAUSTED_RANGE 367 -#define _ITER_NEXT_RANGE 368 +#define _ITER_CHECK_LIST 344 +#define _ITER_JUMP_LIST 345 +#define _GUARD_NOT_EXHAUSTED_LIST 346 +#define _ITER_NEXT_LIST 347 +#define _ITER_CHECK_TUPLE 348 +#define _ITER_JUMP_TUPLE 349 +#define _GUARD_NOT_EXHAUSTED_TUPLE 350 +#define _ITER_NEXT_TUPLE 351 +#define _ITER_CHECK_RANGE 352 +#define _ITER_JUMP_RANGE 353 +#define _GUARD_NOT_EXHAUSTED_RANGE 354 +#define _ITER_NEXT_RANGE 355 #define _FOR_ITER_GEN FOR_ITER_GEN #define _BEFORE_ASYNC_WITH BEFORE_ASYNC_WITH #define _BEFORE_WITH BEFORE_WITH #define _WITH_EXCEPT_START WITH_EXCEPT_START #define _PUSH_EXC_INFO PUSH_EXC_INFO -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 369 -#define _GUARD_KEYS_VERSION 370 -#define _LOAD_ATTR_METHOD_WITH_VALUES 371 -#define _LOAD_ATTR_METHOD_NO_DICT 372 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 373 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 374 -#define _CHECK_ATTR_METHOD_LAZY_DICT 375 -#define _LOAD_ATTR_METHOD_LAZY_DICT 376 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 356 +#define _GUARD_KEYS_VERSION 357 +#define _LOAD_ATTR_METHOD_WITH_VALUES 358 +#define _LOAD_ATTR_METHOD_NO_DICT 359 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 360 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 361 +#define _CHECK_ATTR_METHOD_LAZY_DICT 362 +#define _LOAD_ATTR_METHOD_LAZY_DICT 363 #define _INSTRUMENTED_CALL INSTRUMENTED_CALL -#define _SPECIALIZE_CALL 377 -#define _CALL 378 -#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS 379 -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 380 -#define _CHECK_PEP_523 381 -#define _CHECK_FUNCTION_EXACT_ARGS 382 -#define _CHECK_STACK_SPACE 383 -#define _INIT_CALL_PY_EXACT_ARGS 384 -#define _PUSH_FRAME 385 +#define _CALL 364 +#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS 365 +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 366 +#define _CHECK_PEP_523 367 +#define _CHECK_FUNCTION_EXACT_ARGS 368 +#define _CHECK_STACK_SPACE 369 +#define _INIT_CALL_PY_EXACT_ARGS 370 +#define _PUSH_FRAME 371 #define _CALL_PY_WITH_DEFAULTS CALL_PY_WITH_DEFAULTS #define _CALL_TYPE_1 CALL_TYPE_1 #define _CALL_STR_1 CALL_STR_1 @@ -227,7 +199,6 @@ extern "C" { #define _CALL_BUILTIN_FAST_WITH_KEYWORDS CALL_BUILTIN_FAST_WITH_KEYWORDS #define _CALL_LEN CALL_LEN #define _CALL_ISINSTANCE CALL_ISINSTANCE -#define _CALL_LIST_APPEND CALL_LIST_APPEND #define _CALL_METHOD_DESCRIPTOR_O CALL_METHOD_DESCRIPTOR_O #define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS #define _CALL_METHOD_DESCRIPTOR_NOARGS CALL_METHOD_DESCRIPTOR_NOARGS @@ -238,14 +209,12 @@ extern "C" { #define _CALL_FUNCTION_EX CALL_FUNCTION_EX #define _MAKE_FUNCTION MAKE_FUNCTION #define _SET_FUNCTION_ATTRIBUTE SET_FUNCTION_ATTRIBUTE -#define _RETURN_GENERATOR RETURN_GENERATOR #define _BUILD_SLICE BUILD_SLICE #define _CONVERT_VALUE CONVERT_VALUE #define _FORMAT_SIMPLE FORMAT_SIMPLE #define _FORMAT_WITH_SPEC FORMAT_WITH_SPEC #define _COPY COPY -#define _SPECIALIZE_BINARY_OP 386 -#define _BINARY_OP 387 +#define _BINARY_OP 372 #define _SWAP SWAP #define _INSTRUMENTED_INSTRUCTION INSTRUMENTED_INSTRUCTION #define _INSTRUMENTED_JUMP_FORWARD INSTRUMENTED_JUMP_FORWARD @@ -254,15 +223,15 @@ extern "C" { #define _INSTRUMENTED_POP_JUMP_IF_FALSE INSTRUMENTED_POP_JUMP_IF_FALSE #define _INSTRUMENTED_POP_JUMP_IF_NONE INSTRUMENTED_POP_JUMP_IF_NONE #define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE INSTRUMENTED_POP_JUMP_IF_NOT_NONE -#define _GUARD_IS_TRUE_POP 388 -#define _GUARD_IS_FALSE_POP 389 -#define _GUARD_IS_NONE_POP 390 -#define _GUARD_IS_NOT_NONE_POP 391 -#define _JUMP_TO_TOP 392 -#define _SAVE_RETURN_OFFSET 393 -#define _INSERT 394 -#define _CHECK_VALIDITY 395 -#define MAX_UOP_ID 395 +#define _GUARD_IS_TRUE_POP 373 +#define _GUARD_IS_FALSE_POP 374 +#define _GUARD_IS_NONE_POP 375 +#define _GUARD_IS_NOT_NONE_POP 376 +#define _JUMP_TO_TOP 377 +#define _SAVE_RETURN_OFFSET 378 +#define _INSERT 379 +#define _CHECK_VALIDITY 380 +#define MAX_UOP_ID 380 #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index f228d05917223c..233e21aa922c60 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -17,9 +17,7 @@ extern const char * const _PyOpcode_uop_name[MAX_UOP_ID+1]; #ifdef NEED_OPCODE_METADATA const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_NOP] = 0, - [_RESUME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_RESUME_CHECK] = HAS_DEOPT_FLAG, - [_INSTRUMENTED_RESUME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_FAST_CHECK] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ERROR_FLAG, [_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, [_LOAD_FAST_AND_CLEAR] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, @@ -30,12 +28,9 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_STORE_FAST_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG, [_POP_TOP] = 0, [_PUSH_NULL] = 0, - [_INSTRUMENTED_END_FOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_END_SEND] = 0, - [_INSTRUMENTED_END_SEND] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_UNARY_NEGATIVE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_UNARY_NOT] = 0, - [_SPECIALIZE_TO_BOOL] = HAS_ESCAPES_FLAG, [_TO_BOOL] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_TO_BOOL_BOOL] = HAS_DEOPT_FLAG, [_TO_BOOL_INT] = HAS_DEOPT_FLAG, @@ -54,8 +49,6 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BINARY_OP_SUBTRACT_FLOAT] = 0, [_GUARD_BOTH_UNICODE] = HAS_DEOPT_FLAG, [_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_BINARY_SUBSCR] = HAS_ESCAPES_FLAG, [_BINARY_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_STORE_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -63,44 +56,28 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BINARY_SUBSCR_STR_INT] = HAS_DEOPT_FLAG, [_BINARY_SUBSCR_TUPLE_INT] = HAS_DEOPT_FLAG, [_BINARY_SUBSCR_DICT] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BINARY_SUBSCR_GETITEM] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_LIST_APPEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_SET_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_STORE_SUBSCR] = HAS_ESCAPES_FLAG, [_STORE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_STORE_SUBSCR_LIST_INT] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_STORE_SUBSCR_DICT] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_DELETE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_RAISE_VARARGS] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_INTERPRETER_EXIT] = HAS_ESCAPES_FLAG, [_POP_FRAME] = HAS_ESCAPES_FLAG, - [_INSTRUMENTED_RETURN_VALUE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_RETURN_CONST] = HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_AITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_AWAITABLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_SEND] = HAS_ESCAPES_FLAG, - [_SEND] = HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SEND_GEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_YIELD_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_YIELD_VALUE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_POP_EXCEPT] = HAS_ESCAPES_FLAG, - [_RERAISE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_END_ASYNC_FOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CLEANUP_THROW] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_ASSERTION_ERROR] = 0, [_LOAD_BUILD_CLASS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_STORE_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_DELETE_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_UNPACK_SEQUENCE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_UNPACK_SEQUENCE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_UNPACK_SEQUENCE_TWO_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_UNPACK_SEQUENCE_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_UNPACK_SEQUENCE_LIST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_UNPACK_EX] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_STORE_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG, [_STORE_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_DELETE_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_STORE_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -108,7 +85,6 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_LOAD_LOCALS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_FROM_DICT_OR_GLOBALS] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG, [_LOAD_GLOBAL] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GUARD_GLOBALS_VERSION] = HAS_DEOPT_FLAG, [_GUARD_BUILTINS_VERSION] = HAS_DEOPT_FLAG, @@ -133,12 +109,8 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_DICT_UPDATE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_DICT_MERGE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MAP_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_LOAD_SUPER_ATTR] = HAS_ARG_FLAG, - [_SPECIALIZE_LOAD_SUPER_ATTR] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_SUPER_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_SUPER_ATTR_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_LOAD_SUPER_ATTR_METHOD] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_LOAD_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ESCAPES_FLAG, [_LOAD_ATTR] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GUARD_TYPE_VERSION] = HAS_DEOPT_FLAG, [_CHECK_MANAGED_OBJECT_HAS_VALUES] = HAS_DEOPT_FLAG, @@ -150,13 +122,9 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_LOAD_ATTR_SLOT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_CHECK_ATTR_CLASS] = HAS_DEOPT_FLAG, [_LOAD_ATTR_CLASS] = HAS_ARG_FLAG, - [_LOAD_ATTR_PROPERTY] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, - [_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_GUARD_DORV_VALUES] = HAS_DEOPT_FLAG, [_STORE_ATTR_INSTANCE_VALUE] = HAS_ESCAPES_FLAG, - [_STORE_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_STORE_ATTR_SLOT] = HAS_ESCAPES_FLAG, - [_SPECIALIZE_COMPARE_OP] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_COMPARE_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_COMPARE_OP_FLOAT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_COMPARE_OP_INT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, @@ -165,15 +133,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CONTAINS_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_EG_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_EXC_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_IMPORT_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_IMPORT_FROM] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_JUMP_FORWARD] = HAS_ARG_FLAG | HAS_JUMP_FLAG, - [_JUMP_BACKWARD] = HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_ENTER_EXECUTOR] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_POP_JUMP_IF_FALSE] = HAS_ARG_FLAG | HAS_JUMP_FLAG, - [_POP_JUMP_IF_TRUE] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_IS_NONE] = 0, - [_JUMP_BACKWARD_NO_INTERRUPT] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_GET_LEN] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MATCH_CLASS] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MATCH_MAPPING] = 0, @@ -181,23 +141,16 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_MATCH_KEYS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_ITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_YIELD_FROM_ITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_FOR_ITER] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_FOR_ITER] = HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_FOR_ITER_TIER_TWO] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_FOR_ITER] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_ITER_CHECK_LIST] = HAS_DEOPT_FLAG, - [_ITER_JUMP_LIST] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_GUARD_NOT_EXHAUSTED_LIST] = HAS_DEOPT_FLAG, [_ITER_NEXT_LIST] = 0, [_ITER_CHECK_TUPLE] = HAS_DEOPT_FLAG, - [_ITER_JUMP_TUPLE] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_GUARD_NOT_EXHAUSTED_TUPLE] = HAS_DEOPT_FLAG, [_ITER_NEXT_TUPLE] = 0, [_ITER_CHECK_RANGE] = HAS_DEOPT_FLAG, - [_ITER_JUMP_RANGE] = HAS_ARG_FLAG | HAS_JUMP_FLAG, [_GUARD_NOT_EXHAUSTED_RANGE] = HAS_DEOPT_FLAG, [_ITER_NEXT_RANGE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_FOR_ITER_GEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_BEFORE_ASYNC_WITH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BEFORE_WITH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_WITH_EXCEPT_START] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -210,9 +163,6 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = HAS_ARG_FLAG, [_CHECK_ATTR_METHOD_LAZY_DICT] = HAS_DEOPT_FLAG, [_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_CALL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_SPECIALIZE_CALL] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_CALL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = HAS_ARG_FLAG, [_CHECK_PEP_523] = HAS_DEOPT_FLAG, @@ -220,11 +170,9 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CHECK_STACK_SPACE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_INIT_CALL_PY_EXACT_ARGS] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_PUSH_FRAME] = 0, - [_CALL_PY_WITH_DEFAULTS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, [_CALL_TYPE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_ALLOC_AND_ENTER_INIT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -232,36 +180,19 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_LEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_ISINSTANCE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_LIST_APPEND] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_CALL_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_CALL_FUNCTION_EX] = 0, - [_CALL_FUNCTION_EX] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, - [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_FORMAT_WITH_SPEC] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_COPY] = HAS_ARG_FLAG, - [_SPECIALIZE_BINARY_OP] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_SWAP] = HAS_ARG_FLAG, - [_INSTRUMENTED_INSTRUCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_INSTRUMENTED_JUMP_FORWARD] = HAS_ARG_FLAG, - [_INSTRUMENTED_JUMP_BACKWARD] = HAS_ARG_FLAG, - [_INSTRUMENTED_POP_JUMP_IF_TRUE] = HAS_ARG_FLAG, - [_INSTRUMENTED_POP_JUMP_IF_FALSE] = HAS_ARG_FLAG, - [_INSTRUMENTED_POP_JUMP_IF_NONE] = HAS_ARG_FLAG, - [_INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = HAS_ARG_FLAG, - [_EXTENDED_ARG] = HAS_ARG_FLAG, - [_CACHE] = HAS_ESCAPES_FLAG, - [_RESERVED] = HAS_ESCAPES_FLAG, [_GUARD_IS_TRUE_POP] = HAS_DEOPT_FLAG, [_GUARD_IS_FALSE_POP] = HAS_DEOPT_FLAG, [_GUARD_IS_NONE_POP] = HAS_DEOPT_FLAG, diff --git a/Python/optimizer.c b/Python/optimizer.c index 9eb3d87696d45e..607fa33bb4760d 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -8,7 +8,6 @@ #include "pycore_pystate.h" // _PyInterpreterState_GET() #include "pycore_uop_ids.h" #include "pycore_uops.h" -#include "pycore_uop_metadata.h" #include "cpython/optimizer.h" #include #include @@ -16,6 +15,12 @@ #define MAX_EXECUTORS_SIZE 256 + +#define NEED_OPCODE_METADATA +#include "pycore_uop_metadata.h" // Uop tables +#undef NEED_OPCODE_METADATA + + static bool has_space_for_executor(PyCodeObject *code, _Py_CODEUNIT *instr) { diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 309b0552e21902..b47ade1630c008 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -159,23 +159,29 @@ def generate_deopt_table( def generate_cache_table( analysis: Analysis, out: CWriter ) -> None: + out.emit("extern const uint8_t _PyOpcode_Caches[256];\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const uint8_t _PyOpcode_Caches[256] = {\n") for inst in analysis.instructions.values(): if inst.size > 1: out.emit(f"[{inst.name}] = {inst.size-1},\n") - out.emit("};\n\n") + out.emit("};\n") + out.emit("#endif\n\n") def generate_name_table( analysis: Analysis, out: CWriter ) -> None: table_size = 256 + len(analysis.pseudos) + out.emit(f"extern const char *_PyOpcode_OpName[{table_size}];\n") + out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit(f"const char *_PyOpcode_OpName[{table_size}] = {{\n") names = list(analysis.instructions) + list(analysis.pseudos) names.append("INSTRUMENTED_LINE") for name in sorted(names): out.emit(f'[{name}] = "{name}",\n') - out.emit("};\n\n") + out.emit("};\n") + out.emit("#endif\n\n") def generate_metadata_table( @@ -269,9 +275,9 @@ def generate_psuedo_targets( out.emit("struct pseudo_targets {\n") out.emit(f"uint8_t targets[{max_targets + 1}];\n") out.emit("};\n") - out.emit(f"const struct pseudo_targets pseudo_targets[{table_size}];\n") + out.emit(f"extern const struct pseudo_targets _PyOpcode_PseudoTargets[{table_size}];\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") - out.emit(f"const struct pseudo_targets pseudo_targets[{table_size}] = {{\n") + out.emit(f"const struct pseudo_targets _PyOpcode_PseudoTargets[{table_size}] = {{\n") for pseudo in analysis.pseudos.values(): targets = [ "0" ] * (max_targets + 1) for i, target in enumerate(pseudo.targets): @@ -284,8 +290,8 @@ def generate_psuedo_targets( out.emit(f"if (pseudo < 256 || pseudo >= {256+table_size}) {{\n") out.emit(f"return false;\n") out.emit("}\n") - out.emit(f"for (int i = 0; pseudo_targets[pseudo-256].targets[i]; i++) {{\n") - out.emit(f"if (pseudo_targets[pseudo-256].targets[i] == target) return true;\n") + out.emit(f"for (int i = 0; _PyOpcode_PseudoTargets[pseudo-256].targets[i]; i++) {{\n") + out.emit(f"if (_PyOpcode_PseudoTargets[pseudo-256].targets[i] == target) return true;\n") out.emit("}\n") out.emit(f"return false;\n") out.emit("}\n\n") diff --git a/Tools/cases_generator/uop_id_generator.py b/Tools/cases_generator/uop_id_generator.py index 33cf5741226e6c..97205dbb7a0629 100644 --- a/Tools/cases_generator/uop_id_generator.py +++ b/Tools/cases_generator/uop_id_generator.py @@ -23,10 +23,6 @@ DEFAULT_OUTPUT = ROOT / "Include/internal/pycore_uop_ids.h" - -OMIT = {"_CACHE", "_RESERVED", "_EXTENDED_ARG"} - - def generate_uop_ids( filenames: list[str], analysis: Analysis, outfile: TextIO, distinct_namespace: bool ) -> None: @@ -44,9 +40,7 @@ def generate_uop_ids( for uop in analysis.uops.values(): if uop.name in PRE_DEFINED: continue - # TODO: We should omit all tier-1 only uops, but - # generate_cases.py still generates code for those. - if uop.name in OMIT: + if uop.properties.tier_one_only: continue if uop.implicitly_created and not distinct_namespace: out.emit(f"#define {uop.name} {uop.name[1:]}\n") diff --git a/Tools/cases_generator/uop_metadata_generator.py b/Tools/cases_generator/uop_metadata_generator.py index fa14a0757547b8..1178b9279531f2 100644 --- a/Tools/cases_generator/uop_metadata_generator.py +++ b/Tools/cases_generator/uop_metadata_generator.py @@ -33,13 +33,15 @@ def generate_names_and_flags( out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = {\n") for uop in analysis.uops.values(): - out.emit(f"[{uop.name}] = {cflags(uop.properties)},\n") + if uop.is_viable() and not uop.properties.tier_one_only: + out.emit(f"[{uop.name}] = {cflags(uop.properties)},\n") out.emit("};\n\n") out.emit("const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = {\n") names = [uop.name for uop in analysis.uops.values()] for name in sorted(names): - out.emit(f'[{name}] = "{name}",\n') + if uop.is_viable() and not uop.properties.tier_one_only: + out.emit(f'[{name}] = "{name}",\n') out.emit("};\n") out.emit("#endif // NEED_OPCODE_METADATA\n\n") From 2546bb266ef6e8f6c038fd96a58c504e78bc279c Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 12:41:29 +0000 Subject: [PATCH 24/51] Generate Python file --- Include/internal/pycore_uop_metadata.h | 69 ------------------- Lib/_opcode_metadata.py | 20 +++--- Makefile.pre.in | 3 +- Python/assemble.c | 2 +- Tools/cases_generator/analyzer.py | 9 ++- Tools/cases_generator/generate_cases.py | 1 - Tools/cases_generator/generators_common.py | 20 +++++- Tools/cases_generator/opcode_id_generator.py | 18 ++--- .../cases_generator/uop_metadata_generator.py | 7 +- 9 files changed, 46 insertions(+), 103 deletions(-) diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 233e21aa922c60..f003aaf409a2af 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -212,7 +212,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_BINARY_OP_ADD_FLOAT] = "_BINARY_OP_ADD_FLOAT", [_BINARY_OP_ADD_INT] = "_BINARY_OP_ADD_INT", [_BINARY_OP_ADD_UNICODE] = "_BINARY_OP_ADD_UNICODE", - [_BINARY_OP_INPLACE_ADD_UNICODE] = "_BINARY_OP_INPLACE_ADD_UNICODE", [_BINARY_OP_MULTIPLY_FLOAT] = "_BINARY_OP_MULTIPLY_FLOAT", [_BINARY_OP_MULTIPLY_INT] = "_BINARY_OP_MULTIPLY_INT", [_BINARY_OP_SUBTRACT_FLOAT] = "_BINARY_OP_SUBTRACT_FLOAT", @@ -220,7 +219,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_BINARY_SLICE] = "_BINARY_SLICE", [_BINARY_SUBSCR] = "_BINARY_SUBSCR", [_BINARY_SUBSCR_DICT] = "_BINARY_SUBSCR_DICT", - [_BINARY_SUBSCR_GETITEM] = "_BINARY_SUBSCR_GETITEM", [_BINARY_SUBSCR_LIST_INT] = "_BINARY_SUBSCR_LIST_INT", [_BINARY_SUBSCR_STR_INT] = "_BINARY_SUBSCR_STR_INT", [_BINARY_SUBSCR_TUPLE_INT] = "_BINARY_SUBSCR_TUPLE_INT", @@ -231,25 +229,18 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_BUILD_SLICE] = "_BUILD_SLICE", [_BUILD_STRING] = "_BUILD_STRING", [_BUILD_TUPLE] = "_BUILD_TUPLE", - [_CACHE] = "_CACHE", - [_CALL] = "_CALL", - [_CALL_ALLOC_AND_ENTER_INIT] = "_CALL_ALLOC_AND_ENTER_INIT", [_CALL_BUILTIN_CLASS] = "_CALL_BUILTIN_CLASS", [_CALL_BUILTIN_FAST] = "_CALL_BUILTIN_FAST", [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = "_CALL_BUILTIN_FAST_WITH_KEYWORDS", [_CALL_BUILTIN_O] = "_CALL_BUILTIN_O", - [_CALL_FUNCTION_EX] = "_CALL_FUNCTION_EX", [_CALL_INTRINSIC_1] = "_CALL_INTRINSIC_1", [_CALL_INTRINSIC_2] = "_CALL_INTRINSIC_2", [_CALL_ISINSTANCE] = "_CALL_ISINSTANCE", - [_CALL_KW] = "_CALL_KW", [_CALL_LEN] = "_CALL_LEN", - [_CALL_LIST_APPEND] = "_CALL_LIST_APPEND", [_CALL_METHOD_DESCRIPTOR_FAST] = "_CALL_METHOD_DESCRIPTOR_FAST", [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = "_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", [_CALL_METHOD_DESCRIPTOR_NOARGS] = "_CALL_METHOD_DESCRIPTOR_NOARGS", [_CALL_METHOD_DESCRIPTOR_O] = "_CALL_METHOD_DESCRIPTOR_O", - [_CALL_PY_WITH_DEFAULTS] = "_CALL_PY_WITH_DEFAULTS", [_CALL_STR_1] = "_CALL_STR_1", [_CALL_TUPLE_1] = "_CALL_TUPLE_1", [_CALL_TYPE_1] = "_CALL_TYPE_1", @@ -265,7 +256,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_CHECK_PEP_523] = "_CHECK_PEP_523", [_CHECK_STACK_SPACE] = "_CHECK_STACK_SPACE", [_CHECK_VALIDITY] = "_CHECK_VALIDITY", - [_CLEANUP_THROW] = "_CLEANUP_THROW", [_COMPARE_OP] = "_COMPARE_OP", [_COMPARE_OP_FLOAT] = "_COMPARE_OP_FLOAT", [_COMPARE_OP_INT] = "_COMPARE_OP_INT", @@ -282,16 +272,11 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_DELETE_SUBSCR] = "_DELETE_SUBSCR", [_DICT_MERGE] = "_DICT_MERGE", [_DICT_UPDATE] = "_DICT_UPDATE", - [_END_ASYNC_FOR] = "_END_ASYNC_FOR", [_END_SEND] = "_END_SEND", - [_ENTER_EXECUTOR] = "_ENTER_EXECUTOR", [_EXIT_INIT_CHECK] = "_EXIT_INIT_CHECK", [_EXIT_TRACE] = "_EXIT_TRACE", - [_EXTENDED_ARG] = "_EXTENDED_ARG", [_FORMAT_SIMPLE] = "_FORMAT_SIMPLE", [_FORMAT_WITH_SPEC] = "_FORMAT_WITH_SPEC", - [_FOR_ITER] = "_FOR_ITER", - [_FOR_ITER_GEN] = "_FOR_ITER_GEN", [_FOR_ITER_TIER_TWO] = "_FOR_ITER_TIER_TWO", [_GET_AITER] = "_GET_AITER", [_GET_ANEXT] = "_GET_ANEXT", @@ -315,51 +300,23 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_GUARD_NOT_EXHAUSTED_RANGE] = "_GUARD_NOT_EXHAUSTED_RANGE", [_GUARD_NOT_EXHAUSTED_TUPLE] = "_GUARD_NOT_EXHAUSTED_TUPLE", [_GUARD_TYPE_VERSION] = "_GUARD_TYPE_VERSION", - [_IMPORT_FROM] = "_IMPORT_FROM", - [_IMPORT_NAME] = "_IMPORT_NAME", [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = "_INIT_CALL_BOUND_METHOD_EXACT_ARGS", [_INIT_CALL_PY_EXACT_ARGS] = "_INIT_CALL_PY_EXACT_ARGS", [_INSERT] = "_INSERT", - [_INSTRUMENTED_CALL] = "_INSTRUMENTED_CALL", - [_INSTRUMENTED_CALL_FUNCTION_EX] = "_INSTRUMENTED_CALL_FUNCTION_EX", - [_INSTRUMENTED_CALL_KW] = "_INSTRUMENTED_CALL_KW", - [_INSTRUMENTED_END_FOR] = "_INSTRUMENTED_END_FOR", - [_INSTRUMENTED_END_SEND] = "_INSTRUMENTED_END_SEND", - [_INSTRUMENTED_FOR_ITER] = "_INSTRUMENTED_FOR_ITER", - [_INSTRUMENTED_INSTRUCTION] = "_INSTRUMENTED_INSTRUCTION", - [_INSTRUMENTED_JUMP_BACKWARD] = "_INSTRUMENTED_JUMP_BACKWARD", - [_INSTRUMENTED_JUMP_FORWARD] = "_INSTRUMENTED_JUMP_FORWARD", - [_INSTRUMENTED_LOAD_SUPER_ATTR] = "_INSTRUMENTED_LOAD_SUPER_ATTR", - [_INSTRUMENTED_POP_JUMP_IF_FALSE] = "_INSTRUMENTED_POP_JUMP_IF_FALSE", - [_INSTRUMENTED_POP_JUMP_IF_NONE] = "_INSTRUMENTED_POP_JUMP_IF_NONE", - [_INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = "_INSTRUMENTED_POP_JUMP_IF_NOT_NONE", - [_INSTRUMENTED_POP_JUMP_IF_TRUE] = "_INSTRUMENTED_POP_JUMP_IF_TRUE", - [_INSTRUMENTED_RESUME] = "_INSTRUMENTED_RESUME", - [_INSTRUMENTED_RETURN_CONST] = "_INSTRUMENTED_RETURN_CONST", - [_INSTRUMENTED_RETURN_VALUE] = "_INSTRUMENTED_RETURN_VALUE", - [_INSTRUMENTED_YIELD_VALUE] = "_INSTRUMENTED_YIELD_VALUE", - [_INTERPRETER_EXIT] = "_INTERPRETER_EXIT", [_IS_NONE] = "_IS_NONE", [_IS_OP] = "_IS_OP", [_ITER_CHECK_LIST] = "_ITER_CHECK_LIST", [_ITER_CHECK_RANGE] = "_ITER_CHECK_RANGE", [_ITER_CHECK_TUPLE] = "_ITER_CHECK_TUPLE", - [_ITER_JUMP_LIST] = "_ITER_JUMP_LIST", - [_ITER_JUMP_RANGE] = "_ITER_JUMP_RANGE", - [_ITER_JUMP_TUPLE] = "_ITER_JUMP_TUPLE", [_ITER_NEXT_LIST] = "_ITER_NEXT_LIST", [_ITER_NEXT_RANGE] = "_ITER_NEXT_RANGE", [_ITER_NEXT_TUPLE] = "_ITER_NEXT_TUPLE", - [_JUMP_BACKWARD] = "_JUMP_BACKWARD", - [_JUMP_BACKWARD_NO_INTERRUPT] = "_JUMP_BACKWARD_NO_INTERRUPT", - [_JUMP_FORWARD] = "_JUMP_FORWARD", [_JUMP_TO_TOP] = "_JUMP_TO_TOP", [_LIST_APPEND] = "_LIST_APPEND", [_LIST_EXTEND] = "_LIST_EXTEND", [_LOAD_ASSERTION_ERROR] = "_LOAD_ASSERTION_ERROR", [_LOAD_ATTR] = "_LOAD_ATTR", [_LOAD_ATTR_CLASS] = "_LOAD_ATTR_CLASS", - [_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = "_LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN", [_LOAD_ATTR_INSTANCE_VALUE] = "_LOAD_ATTR_INSTANCE_VALUE", [_LOAD_ATTR_METHOD_LAZY_DICT] = "_LOAD_ATTR_METHOD_LAZY_DICT", [_LOAD_ATTR_METHOD_NO_DICT] = "_LOAD_ATTR_METHOD_NO_DICT", @@ -367,7 +324,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_LOAD_ATTR_MODULE] = "_LOAD_ATTR_MODULE", [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "_LOAD_ATTR_NONDESCRIPTOR_NO_DICT", [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = "_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES", - [_LOAD_ATTR_PROPERTY] = "_LOAD_ATTR_PROPERTY", [_LOAD_ATTR_SLOT] = "_LOAD_ATTR_SLOT", [_LOAD_ATTR_WITH_HINT] = "_LOAD_ATTR_WITH_HINT", [_LOAD_BUILD_CLASS] = "_LOAD_BUILD_CLASS", @@ -384,7 +340,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_LOAD_GLOBAL_MODULE] = "_LOAD_GLOBAL_MODULE", [_LOAD_LOCALS] = "_LOAD_LOCALS", [_LOAD_NAME] = "_LOAD_NAME", - [_LOAD_SUPER_ATTR] = "_LOAD_SUPER_ATTR", [_LOAD_SUPER_ATTR_ATTR] = "_LOAD_SUPER_ATTR_ATTR", [_LOAD_SUPER_ATTR_METHOD] = "_LOAD_SUPER_ATTR_METHOD", [_MAKE_CELL] = "_MAKE_CELL", @@ -397,43 +352,20 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_NOP] = "_NOP", [_POP_EXCEPT] = "_POP_EXCEPT", [_POP_FRAME] = "_POP_FRAME", - [_POP_JUMP_IF_FALSE] = "_POP_JUMP_IF_FALSE", - [_POP_JUMP_IF_TRUE] = "_POP_JUMP_IF_TRUE", [_POP_TOP] = "_POP_TOP", [_PUSH_EXC_INFO] = "_PUSH_EXC_INFO", [_PUSH_FRAME] = "_PUSH_FRAME", [_PUSH_NULL] = "_PUSH_NULL", - [_RAISE_VARARGS] = "_RAISE_VARARGS", - [_RERAISE] = "_RERAISE", - [_RESERVED] = "_RESERVED", - [_RESUME] = "_RESUME", [_RESUME_CHECK] = "_RESUME_CHECK", - [_RETURN_GENERATOR] = "_RETURN_GENERATOR", [_SAVE_RETURN_OFFSET] = "_SAVE_RETURN_OFFSET", - [_SEND] = "_SEND", - [_SEND_GEN] = "_SEND_GEN", [_SETUP_ANNOTATIONS] = "_SETUP_ANNOTATIONS", [_SET_ADD] = "_SET_ADD", [_SET_FUNCTION_ATTRIBUTE] = "_SET_FUNCTION_ATTRIBUTE", [_SET_IP] = "_SET_IP", [_SET_UPDATE] = "_SET_UPDATE", - [_SPECIALIZE_BINARY_OP] = "_SPECIALIZE_BINARY_OP", - [_SPECIALIZE_BINARY_SUBSCR] = "_SPECIALIZE_BINARY_SUBSCR", - [_SPECIALIZE_CALL] = "_SPECIALIZE_CALL", - [_SPECIALIZE_COMPARE_OP] = "_SPECIALIZE_COMPARE_OP", - [_SPECIALIZE_FOR_ITER] = "_SPECIALIZE_FOR_ITER", - [_SPECIALIZE_LOAD_ATTR] = "_SPECIALIZE_LOAD_ATTR", - [_SPECIALIZE_LOAD_GLOBAL] = "_SPECIALIZE_LOAD_GLOBAL", - [_SPECIALIZE_LOAD_SUPER_ATTR] = "_SPECIALIZE_LOAD_SUPER_ATTR", - [_SPECIALIZE_SEND] = "_SPECIALIZE_SEND", - [_SPECIALIZE_STORE_ATTR] = "_SPECIALIZE_STORE_ATTR", - [_SPECIALIZE_STORE_SUBSCR] = "_SPECIALIZE_STORE_SUBSCR", - [_SPECIALIZE_TO_BOOL] = "_SPECIALIZE_TO_BOOL", - [_SPECIALIZE_UNPACK_SEQUENCE] = "_SPECIALIZE_UNPACK_SEQUENCE", [_STORE_ATTR] = "_STORE_ATTR", [_STORE_ATTR_INSTANCE_VALUE] = "_STORE_ATTR_INSTANCE_VALUE", [_STORE_ATTR_SLOT] = "_STORE_ATTR_SLOT", - [_STORE_ATTR_WITH_HINT] = "_STORE_ATTR_WITH_HINT", [_STORE_DEREF] = "_STORE_DEREF", [_STORE_FAST] = "_STORE_FAST", [_STORE_FAST_LOAD_FAST] = "_STORE_FAST_LOAD_FAST", @@ -461,7 +393,6 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_UNPACK_SEQUENCE_TUPLE] = "_UNPACK_SEQUENCE_TUPLE", [_UNPACK_SEQUENCE_TWO_TUPLE] = "_UNPACK_SEQUENCE_TWO_TUPLE", [_WITH_EXCEPT_START] = "_WITH_EXCEPT_START", - [_YIELD_VALUE] = "_YIELD_VALUE", }; #endif // NEED_OPCODE_METADATA diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index 5dd06ae487dfcf..67b54772915d31 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -1,8 +1,7 @@ -# This file is generated by Tools/cases_generator/generate_cases.py +# This file is generated by Tools/cases_generator/py_metadata_generator.py # from: # Python/bytecodes.c # Do not edit! - _specializations = { "RESUME": [ "RESUME_CHECK", @@ -23,6 +22,7 @@ "BINARY_OP_ADD_FLOAT", "BINARY_OP_SUBTRACT_FLOAT", "BINARY_OP_ADD_UNICODE", + "BINARY_OP_INPLACE_ADD_UNICODE", ], "BINARY_SUBSCR": [ "BINARY_SUBSCR_DICT", @@ -103,14 +103,11 @@ ], } -# An irregular case: -_specializations["BINARY_OP"].append("BINARY_OP_INPLACE_ADD_UNICODE") - _specialized_opmap = { - 'BINARY_OP_INPLACE_ADD_UNICODE': 3, 'BINARY_OP_ADD_FLOAT': 150, 'BINARY_OP_ADD_INT': 151, 'BINARY_OP_ADD_UNICODE': 152, + 'BINARY_OP_INPLACE_ADD_UNICODE': 3, 'BINARY_OP_MULTIPLY_FLOAT': 153, 'BINARY_OP_MULTIPLY_INT': 154, 'BINARY_OP_SUBTRACT_FLOAT': 155, @@ -179,8 +176,11 @@ 'UNPACK_SEQUENCE_TWO_TUPLE': 218, } -opmap = { +_opmap = { 'CACHE': 0, + 'RESERVED': 17, + 'RESUME': 149, + 'INSTRUMENTED_LINE': 254, 'BEFORE_ASYNC_WITH': 1, 'BEFORE_WITH': 2, 'BINARY_SLICE': 4, @@ -196,7 +196,6 @@ 'FORMAT_SIMPLE': 14, 'FORMAT_WITH_SPEC': 15, 'GET_AITER': 16, - 'RESERVED': 17, 'GET_ANEXT': 18, 'GET_ITER': 19, 'GET_LEN': 20, @@ -298,7 +297,6 @@ 'UNPACK_EX': 116, 'UNPACK_SEQUENCE': 117, 'YIELD_VALUE': 118, - 'RESUME': 149, 'INSTRUMENTED_RESUME': 236, 'INSTRUMENTED_END_FOR': 237, 'INSTRUMENTED_END_SEND': 238, @@ -317,7 +315,6 @@ 'INSTRUMENTED_POP_JUMP_IF_FALSE': 251, 'INSTRUMENTED_POP_JUMP_IF_NONE': 252, 'INSTRUMENTED_POP_JUMP_IF_NOT_NONE': 253, - 'INSTRUMENTED_LINE': 254, 'JUMP': 256, 'JUMP_NO_INTERRUPT': 257, 'LOAD_CLOSURE': 258, @@ -331,5 +328,6 @@ 'SETUP_WITH': 266, 'STORE_FAST_MAYBE_NULL': 267, } -MIN_INSTRUMENTED_OPCODE = 236 + HAVE_ARGUMENT = 45 +MIN_INSTRUMENTED_OPCODE = 236 diff --git a/Makefile.pre.in b/Makefile.pre.in index f40cc8b0caa618..d10230df1965e8 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -1588,13 +1588,14 @@ regen-cases: $(srcdir)/Tools/cases_generator/generate_cases.py \ $(CASESFLAG) \ -t $(srcdir)/Python/opcode_targets.h.new \ - -p $(srcdir)/Lib/_opcode_metadata.py.new \ -a $(srcdir)/Python/abstract_interp_cases.c.h.new \ $(srcdir)/Python/bytecodes.c $(PYTHON_FOR_REGEN) \ $(srcdir)/Tools/cases_generator/opcode_id_generator.py -o $(srcdir)/Include/opcode_ids.h.new $(srcdir)/Python/bytecodes.c $(PYTHON_FOR_REGEN) \ $(srcdir)/Tools/cases_generator/uop_id_generator.py -o $(srcdir)/Include/internal/pycore_uop_ids.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) \ + $(srcdir)/Tools/cases_generator/py_metadata_generator.py -o $(srcdir)/Lib/_opcode_metadata.py.new $(srcdir)/Python/bytecodes.c $(PYTHON_FOR_REGEN) \ $(srcdir)/Tools/cases_generator/tier1_generator.py -o $(srcdir)/Python/generated_cases.c.h.new $(srcdir)/Python/bytecodes.c $(PYTHON_FOR_REGEN) \ diff --git a/Python/assemble.c b/Python/assemble.c index 98057e262f4b59..569454ebf3b9cb 100644 --- a/Python/assemble.c +++ b/Python/assemble.c @@ -4,7 +4,7 @@ #include "pycore_code.h" // write_location_entry_start() #include "pycore_compile.h" #include "pycore_opcode_utils.h" // IS_BACKWARDS_JUMP_OPCODE -#include "pycore_opcode_metadata.h" // IS_PSEUDO_INSTR, _PyOpcode_Caches +#include "pycore_opcode_metadata.h" // is_pseudo_target, _PyOpcode_Caches #define DEFAULT_CODE_SIZE 128 diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 1147ff778b242c..d047c5f29179e5 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -237,8 +237,13 @@ def get_instruction_map(self) -> dict[str, int]: # 149 is RESUME - it is hard coded as such in Tools/build/deepfreeze.py instmap["RESUME"] = 149 + + # This is an historical oddity. + instmap["BINARY_OP_INPLACE_ADD_UNICODE"] = 3 + instmap["INSTRUMENTED_LINE"] = 254 + instrumented = [ name for name in self.instructions if name.startswith("INSTRUMENTED") ] @@ -557,7 +562,9 @@ def analyze_forest(forest: list[parser.AstNode]) -> Analysis: instructions[target.text].is_target = True # Hack if "BINARY_OP_INPLACE_ADD_UNICODE" in instructions: - instructions["BINARY_OP_INPLACE_ADD_UNICODE"].family = families["BINARY_OP"] + inst = instructions["BINARY_OP_INPLACE_ADD_UNICODE"] + inst.family = families["BINARY_OP"] + families["BINARY_OP"].members.append(inst) return Analysis(instructions, uops, families, pseudos) diff --git a/Tools/cases_generator/generate_cases.py b/Tools/cases_generator/generate_cases.py index 50bc14a57fc584..bb027f3b09b654 100644 --- a/Tools/cases_generator/generate_cases.py +++ b/Tools/cases_generator/generate_cases.py @@ -840,7 +840,6 @@ def main() -> None: a.assign_opcode_ids() a.write_opcode_targets(args.opcode_targets_h) - a.write_metadata(args.metadata, args.pymetadata) a.write_abstract_interpreter_instructions( args.abstract_interpreter_cases, args.emit_line_directives ) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 45994ac2779818..a12b792e632713 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -7,10 +7,10 @@ Uop, Part, analyze_files, + Properties, Skip, StackItem, analysis_error, - Properties, ) from cwriter import CWriter from typing import Callable, Mapping, TextIO, Iterator @@ -26,6 +26,7 @@ def root_relative_path(filename: str) -> str: try: return Path(filename).absolute().relative_to(ROOT).as_posix() except ValueError: + # Not relative to root, just return original path. return filename def write_header(generator: str, sources: list[str], outfile: TextIO) -> None: @@ -188,6 +189,7 @@ def emit_tokens( else: out.emit(tkn) + def cflags(p: Properties) -> str: flags: list[str] = [] if p.oparg: @@ -212,3 +214,19 @@ def cflags(p: Properties) -> str: return " | ".join(flags) else: return "0" + +def get_have_arg_and_min_instrumented(instmap: dict[str, int], analysis: Analysis) -> tuple[int, int]: + min_instrumented = 256 + first_arg = 256 + for name, op in instmap.items(): + if name.startswith("INSTRUMENTED") and op < min_instrumented: + min_instrumented = op + if name == "INSTRUMENTED_LINE": + # INSTRUMENTED_LINE is not defined + continue + if name in analysis.pseudos: + continue + if analysis.instructions[name].properties.oparg and op < first_arg: + first_arg = op + return first_arg, min_instrumented + diff --git a/Tools/cases_generator/opcode_id_generator.py b/Tools/cases_generator/opcode_id_generator.py index 36b92898f67d2c..e6e70a0ada70ce 100644 --- a/Tools/cases_generator/opcode_id_generator.py +++ b/Tools/cases_generator/opcode_id_generator.py @@ -16,6 +16,7 @@ DEFAULT_INPUT, ROOT, write_header, + get_have_arg_and_min_instrumented, ) from cwriter import CWriter from typing import TextIO @@ -24,7 +25,7 @@ DEFAULT_OUTPUT = ROOT / "Include/opcode_ids.h" - + def generate_opcode_header(filenames: list[str], analysis: Analysis, outfile: TextIO) -> None: write_header(__file__, filenames, outfile) out = CWriter(outfile, 0, False) @@ -39,19 +40,8 @@ def write_define(name: str, op: int) -> None: write_define(name, op) out.emit("\n") - min_instrumented = 256 - first_arg = 256 - for name, op in instmap.items(): - if name.startswith("INSTRUMENTED") and op < min_instrumented: - min_instrumented = op - if name == "INSTRUMENTED_LINE": - # INSTRUMENTED_LINE is not defined - continue - if name in analysis.pseudos: - continue - if analysis.instructions[name].properties.oparg and op < first_arg: - first_arg = op - write_define("HAVE_ARGUMENT", first_arg) + have_arg, min_instrumented = get_have_arg_and_min_instrumented(instmap, analysis) + write_define("HAVE_ARGUMENT", have_arg) write_define("MIN_INSTRUMENTED_OPCODE", min_instrumented) diff --git a/Tools/cases_generator/uop_metadata_generator.py b/Tools/cases_generator/uop_metadata_generator.py index 1178b9279531f2..537a9458fc5bff 100644 --- a/Tools/cases_generator/uop_metadata_generator.py +++ b/Tools/cases_generator/uop_metadata_generator.py @@ -38,13 +38,12 @@ def generate_names_and_flags( out.emit("};\n\n") out.emit("const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = {\n") - names = [uop.name for uop in analysis.uops.values()] - for name in sorted(names): + for uop in sorted(analysis.uops.values(), key=lambda t:t.name): if uop.is_viable() and not uop.properties.tier_one_only: - out.emit(f'[{name}] = "{name}",\n') + out.emit(f'[{uop.name}] = "{uop.name}",\n') out.emit("};\n") out.emit("#endif // NEED_OPCODE_METADATA\n\n") - + def generate_uop_metadata( filenames: list[str], analysis: Analysis, outfile: TextIO ) -> None: From 0413a4925158e3765e2791d0c55c9d12fb43dc59 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 13:57:46 +0000 Subject: [PATCH 25/51] Compute opmap during analysis phase --- Tools/cases_generator/analyzer.py | 178 ++++++++++-------- Tools/cases_generator/generators_common.py | 4 +- Tools/cases_generator/opcode_id_generator.py | 5 +- .../opcode_metadata_generator.py | 2 +- 4 files changed, 100 insertions(+), 89 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index d047c5f29179e5..471eaedcb78030 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -170,6 +170,7 @@ class Instruction: _properties: Properties | None is_target: bool = False family: Optional["Family"] = None + opcode: int = -1 @property def properties(self) -> Properties: @@ -198,11 +199,13 @@ def is_super(self) -> bool: return False + @dataclass class PseudoInstruction: name: str targets: list[Instruction] flags: list[str] + opcode: int = -1 def dump(self, indent: str) -> None: print(indent, self.name, "->", " or ".join([t.name for t in self.targets])) @@ -224,88 +227,7 @@ class Analysis: uops: dict[str, Uop] families: dict[str, Family] pseudos: dict[str, PseudoInstruction] - - def get_instruction_map(self) -> dict[str, int]: - instmap: dict[str, int] = {} - - # 0 is reserved for cache entries. This helps debugging. - instmap["CACHE"] = 0 - - # 17 is reserved as it is the initial value for the specializing counter. - # This helps catch cases where we attempt to execute a cache. - instmap["RESERVED"] = 17 - - # 149 is RESUME - it is hard coded as such in Tools/build/deepfreeze.py - instmap["RESUME"] = 149 - - # This is an historical oddity. - instmap["BINARY_OP_INPLACE_ADD_UNICODE"] = 3 - - instmap["INSTRUMENTED_LINE"] = 254 - - - instrumented = [ - name for name in self.instructions if name.startswith("INSTRUMENTED") - ] - - # Special case: this instruction is implemented in ceval.c - # rather than bytecodes.c, so we need to add it explicitly - # here (at least until we add something to bytecodes.c to - # declare external instructions). - instrumented.append("INSTRUMENTED_LINE") - - specialized: set[str] = set() - no_arg: list[str] = [] - has_arg: list[str] = [] - - for family in self.families.values(): - specialized.update(inst.name for inst in family.members) - - for inst in self.instructions.values(): - name = inst.name - if name in specialized: - continue - if name in instrumented: - continue - if inst.properties.oparg: - has_arg.append(name) - else: - no_arg.append(name) - - # Specialized ops appear in their own section - # Instrumented opcodes are at the end of the valid range - min_internal = 150 - min_instrumented = 254 - (len(instrumented) - 1) - assert min_internal + len(specialized) < min_instrumented - - next_opcode = 1 - - def add_instruction(name: str) -> None: - nonlocal next_opcode - if name in instmap: - return # Pre-defined name - while next_opcode in instmap.values(): - next_opcode += 1 - instmap[name] = next_opcode - next_opcode += 1 - - for name in sorted(no_arg): - add_instruction(name) - for name in sorted(has_arg): - add_instruction(name) - # For compatibility - next_opcode = min_internal - for name in sorted(specialized): - add_instruction(name) - next_opcode = min_instrumented - for name in instrumented: - add_instruction(name) - - for op, name in enumerate(sorted(self.pseudos), 256): - instmap[name] = op - - assert 255 not in instmap.values() - return instmap + opmap: dict[str, int] def analysis_error(message: str, tkn: lexer.Token) -> SyntaxError: @@ -516,6 +438,95 @@ def add_pseudo( pseudo.flags, ) +def assign_opcodes( + instructions: dict[str, Instruction], + families: dict[str, Family], + pseudos: dict[str, PseudoInstruction], +) -> dict[str, int]: + instmap: dict[str, int] = {} + + # 0 is reserved for cache entries. This helps debugging. + instmap["CACHE"] = 0 + + # 17 is reserved as it is the initial value for the specializing counter. + # This helps catch cases where we attempt to execute a cache. + instmap["RESERVED"] = 17 + + # 149 is RESUME - it is hard coded as such in Tools/build/deepfreeze.py + instmap["RESUME"] = 149 + + # This is an historical oddity. + instmap["BINARY_OP_INPLACE_ADD_UNICODE"] = 3 + + instmap["INSTRUMENTED_LINE"] = 254 + + + instrumented = [ + name for name in instructions if name.startswith("INSTRUMENTED") + ] + + # Special case: this instruction is implemented in ceval.c + # rather than bytecodes.c, so we need to add it explicitly + # here (at least until we add something to bytecodes.c to + # declare external instructions). + instrumented.append("INSTRUMENTED_LINE") + + specialized: set[str] = set() + no_arg: list[str] = [] + has_arg: list[str] = [] + + for family in families.values(): + specialized.update(inst.name for inst in family.members) + + for inst in instructions.values(): + name = inst.name + if name in specialized: + continue + if name in instrumented: + continue + if inst.properties.oparg: + has_arg.append(name) + else: + no_arg.append(name) + + # Specialized ops appear in their own section + # Instrumented opcodes are at the end of the valid range + min_internal = 150 + min_instrumented = 254 - (len(instrumented) - 1) + assert min_internal + len(specialized) < min_instrumented + + next_opcode = 1 + + def add_instruction(name: str) -> None: + nonlocal next_opcode + if name in instmap: + return # Pre-defined name + while next_opcode in instmap.values(): + next_opcode += 1 + instmap[name] = next_opcode + next_opcode += 1 + + for name in sorted(no_arg): + add_instruction(name) + for name in sorted(has_arg): + add_instruction(name) + # For compatibility + next_opcode = min_internal + for name in sorted(specialized): + add_instruction(name) + next_opcode = min_instrumented + for name in instrumented: + add_instruction(name) + + for name in instructions: + instructions[name].opcode = instmap[name] + + for op, name in enumerate(sorted(pseudos), 256): + instmap[name] = op + pseudos[name].opcode = op + + assert 255 not in instmap.values() + return instmap def analyze_forest(forest: list[parser.AstNode]) -> Analysis: instructions: dict[str, Instruction] = {} @@ -565,7 +576,8 @@ def analyze_forest(forest: list[parser.AstNode]) -> Analysis: inst = instructions["BINARY_OP_INPLACE_ADD_UNICODE"] inst.family = families["BINARY_OP"] families["BINARY_OP"].members.append(inst) - return Analysis(instructions, uops, families, pseudos) + opmap = assign_opcodes(instructions, families, pseudos) + return Analysis(instructions, uops, families, pseudos, opmap) def analyze_files(filenames: list[str]) -> Analysis: diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index a12b792e632713..9ad4dc525de142 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -215,10 +215,10 @@ def cflags(p: Properties) -> str: else: return "0" -def get_have_arg_and_min_instrumented(instmap: dict[str, int], analysis: Analysis) -> tuple[int, int]: +def get_have_arg_and_min_instrumented(analysis: Analysis) -> tuple[int, int]: min_instrumented = 256 first_arg = 256 - for name, op in instmap.items(): + for name, op in analysis.opmap.items(): if name.startswith("INSTRUMENTED") and op < min_instrumented: min_instrumented = op if name == "INSTRUMENTED_LINE": diff --git a/Tools/cases_generator/opcode_id_generator.py b/Tools/cases_generator/opcode_id_generator.py index e6e70a0ada70ce..088499359de754 100644 --- a/Tools/cases_generator/opcode_id_generator.py +++ b/Tools/cases_generator/opcode_id_generator.py @@ -29,18 +29,17 @@ def generate_opcode_header(filenames: list[str], analysis: Analysis, outfile: TextIO) -> None: write_header(__file__, filenames, outfile) out = CWriter(outfile, 0, False) - instmap = analysis.get_instruction_map() with out.header_guard("Py_OPCODE_IDS_H"): out.emit("/* Instruction opcodes for compiled code */\n") def write_define(name: str, op: int) -> None: out.emit(f"#define {name:<38} {op:>3}\n") - for op, name in sorted([(op, name) for (name, op) in instmap.items()]): + for op, name in sorted([(op, name) for (name, op) in analysis.opmap.items()]): write_define(name, op) out.emit("\n") - have_arg, min_instrumented = get_have_arg_and_min_instrumented(instmap, analysis) + have_arg, min_instrumented = get_have_arg_and_min_instrumented(analysis) write_define("HAVE_ARGUMENT", have_arg) write_define("MIN_INSTRUMENTED_OPCODE", min_instrumented) diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index b47ade1630c008..b4fe4d5ce39c41 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -260,7 +260,7 @@ def generate_extra_cases( analysis: Analysis, out: CWriter ) -> None: out.emit("#define EXTRA_CASES \\\n") - valid_opcodes = set(analysis.get_instruction_map().values()) + valid_opcodes = set(analysis.opmap.values()) for op in range(256): if op not in valid_opcodes: out.emit(f" case {op}: \\\n") From f06245f52592c543f9e8859961f757f2787193fd Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 13:58:09 +0000 Subject: [PATCH 26/51] Add Python metadata generator --- .../cases_generator/py_metadata_generator.py | 118 ++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 Tools/cases_generator/py_metadata_generator.py diff --git a/Tools/cases_generator/py_metadata_generator.py b/Tools/cases_generator/py_metadata_generator.py new file mode 100644 index 00000000000000..db4878db0de702 --- /dev/null +++ b/Tools/cases_generator/py_metadata_generator.py @@ -0,0 +1,118 @@ +"""Generate uop metedata. +Reads the instruction definitions from bytecodes.c. +Writes the metadata to pycore_uop_metadata.h by default. +""" + +import argparse +import os.path +import sys + +from analyzer import ( + Analysis, + Instruction, + analyze_files, + Uop, +) +from generators_common import ( + DEFAULT_INPUT, + ROOT, + cflags, + root_relative_path, + get_have_arg_and_min_instrumented, +) +from cwriter import CWriter +from typing import TextIO + +def write_header(generator: str, sources: list[str], outfile: TextIO) -> None: + outfile.write( + f"""# This file is generated by {root_relative_path(generator)} +# from: +# {", ".join(root_relative_path(src) for src in sources)} +# Do not edit! +""" + ) + + +DEFAULT_OUTPUT = ROOT / "Lib/_opcode_metadata.py" + +def get_specialized(analysis: Analysis) -> set[str]: + specialized: set[str] = set() + for family in analysis.families.values(): + for member in family.members: + specialized.add(member.name) + return specialized + + +def generate_specializations( + analysis: Analysis, out: CWriter +) -> None: + out.emit("_specializations = {\n") + for family in analysis.families.values(): + out.emit(f'"{family.name}": [\n') + for member in family.members: + out.emit(f' "{member.name}",\n') + out.emit("],\n") + out.emit("}\n\n") + + +def generate_specialized_opmap( + analysis: Analysis, out: CWriter +) -> None: + out.emit("_specialized_opmap = {\n") + names = [] + for family in analysis.families.values(): + for member in family.members: + if member.name == family.name: + continue + names.append(member.name) + for name in sorted(names): + out.emit(f"'{name}': {analysis.opmap[name]},\n") + out.emit("}\n\n") + + +def generate_opmap( + analysis: Analysis, out: CWriter +) -> None: + specialized = get_specialized(analysis) + out.emit("_opmap = {\n") + for inst, op in analysis.opmap.items(): + if inst not in specialized: + out.emit(f"'{inst}': {analysis.opmap[inst]},\n") + out.emit("}\n\n") + + + + +def generate_py_metadata( + filenames: list[str], analysis: Analysis, outfile: TextIO +) -> None: + write_header(__file__, filenames, outfile) + out = CWriter(outfile, 0, False) + generate_specializations(analysis, out) + generate_specialized_opmap(analysis, out) + generate_opmap(analysis, out) + have_arg, min_instrumented = get_have_arg_and_min_instrumented(analysis) + out.emit(f"HAVE_ARGUMENT = {have_arg}\n") + out.emit(f"MIN_INSTRUMENTED_OPCODE = {min_instrumented}\n") + + +arg_parser = argparse.ArgumentParser( + description="Generate the Python file with opcode metadata.", + formatter_class=argparse.ArgumentDefaultsHelpFormatter, +) + +arg_parser.add_argument( + "-o", "--output", type=str, help="Generated code", default=DEFAULT_OUTPUT +) + +arg_parser.add_argument( + "input", nargs=argparse.REMAINDER, help="Instruction definition file(s)" +) + +if __name__ == "__main__": + args = arg_parser.parse_args() + if len(args.input) == 0: + args.input.append(DEFAULT_INPUT) + data = analyze_files(args.input) + with open(args.output, "w") as outfile: + generate_py_metadata(args.input, data, outfile) From 3c80ec09e924a73d8ed6215e8b741ba786bf62f2 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 14:18:47 +0000 Subject: [PATCH 27/51] Generate metadata for psuedo-instructions as well --- Include/internal/pycore_opcode_metadata.h | 20 +++++++++++++++---- Lib/_opcode_metadata.py | 2 +- Tools/cases_generator/analyzer.py | 3 +++ .../opcode_metadata_generator.py | 15 ++++++++++---- .../cases_generator/py_metadata_generator.py | 2 +- 5 files changed, 32 insertions(+), 10 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 10115f0adfc6fa..0524d9e74f0f19 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -930,13 +930,13 @@ enum InstructionFormat { struct opcode_metadata { uint8_t valid_entry; - uint8_t instr_format; - uint16_t flags; + int8_t instr_format; + int16_t flags; }; -extern const struct opcode_metadata _PyOpcode_opcode_metadata[256]; +extern const struct opcode_metadata _PyOpcode_opcode_metadata[268]; #ifdef NEED_OPCODE_METADATA -const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { +const struct opcode_metadata _PyOpcode_opcode_metadata[268] = { [BEFORE_ASYNC_WITH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BEFORE_WITH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1144,6 +1144,18 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, + [JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_NO_INTERRUPT] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG }, + [LOAD_CLOSURE] = { true, -1, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, + [LOAD_METHOD] = { true, -1, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_SUPER_METHOD] = { true, -1, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ZERO_SUPER_ATTR] = { true, -1, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ZERO_SUPER_METHOD] = { true, -1, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [POP_BLOCK] = { true, -1, 0 }, + [SETUP_CLEANUP] = { true, -1, HAS_ARG_FLAG }, + [SETUP_FINALLY] = { true, -1, HAS_ARG_FLAG }, + [SETUP_WITH] = { true, -1, HAS_ARG_FLAG }, + [STORE_FAST_MAYBE_NULL] = { true, -1, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, }; #endif diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index 67b54772915d31..a5119053d557df 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -176,7 +176,7 @@ 'UNPACK_SEQUENCE_TWO_TUPLE': 218, } -_opmap = { +opmap = { 'CACHE': 0, 'RESERVED': 17, 'RESUME': 149, diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 471eaedcb78030..ccf5bfe261342a 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -210,6 +210,9 @@ class PseudoInstruction: def dump(self, indent: str) -> None: print(indent, self.name, "->", " or ".join([t.name for t in self.targets])) + @property + def properties(self) -> Properties: + return Properties.from_list([i.properties for i in self.targets]) @dataclass class Family: diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index b4fe4d5ce39c41..7acbc240190dca 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -187,16 +187,23 @@ def generate_name_table( def generate_metadata_table( analysis: Analysis, out: CWriter ) -> None: + table_size = 256 + len(analysis.pseudos) out.emit("struct opcode_metadata {\n") out.emit("uint8_t valid_entry;\n"); - out.emit("uint8_t instr_format;\n"); - out.emit("uint16_t flags;\n"); + out.emit("int8_t instr_format;\n"); + out.emit("int16_t flags;\n"); out.emit("};\n\n") - out.emit("extern const struct opcode_metadata _PyOpcode_opcode_metadata[256];\n") + out.emit(f"extern const struct opcode_metadata _PyOpcode_opcode_metadata[{table_size}];\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") - out.emit("const struct opcode_metadata _PyOpcode_opcode_metadata[256] = {\n") + out.emit(f"const struct opcode_metadata _PyOpcode_opcode_metadata[{table_size}] = {{\n") for inst in sorted(analysis.instructions.values(), key = lambda t:t.name): out.emit(f"[{inst.name}] = {{ true, {get_format(inst)}, {cflags(inst.properties)} }},\n") + for pseudo in sorted(analysis.pseudos.values(), key = lambda t:t.name): + if pseudo.flags: + flags = " | ".join(f"{flag}_FLAG" for flag in pseudo.flags) + else: + flags = cflags(pseudo.properties) + out.emit(f"[{pseudo.name}] = {{ true, -1, {flags} }},\n") out.emit("};\n") out.emit("#endif\n\n") diff --git a/Tools/cases_generator/py_metadata_generator.py b/Tools/cases_generator/py_metadata_generator.py index db4878db0de702..d80bc419209e2a 100644 --- a/Tools/cases_generator/py_metadata_generator.py +++ b/Tools/cases_generator/py_metadata_generator.py @@ -74,7 +74,7 @@ def generate_opmap( analysis: Analysis, out: CWriter ) -> None: specialized = get_specialized(analysis) - out.emit("_opmap = {\n") + out.emit("opmap = {\n") for inst, op in analysis.opmap.items(): if inst not in specialized: out.emit(f"'{inst}': {analysis.opmap[inst]},\n") From 48d129c9498eb825d2d95a25d19292720923c09e Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 17:13:38 +0000 Subject: [PATCH 28/51] Add HAS_EVAL_BREAK_FLAG --- Include/internal/pycore_opcode_metadata.h | 38 +++++++++++----------- Include/internal/pycore_uop_metadata.h | 22 ++++++------- Tools/cases_generator/analyzer.py | 4 +++ Tools/cases_generator/generators_common.py | 2 ++ 4 files changed, 36 insertions(+), 30 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 0524d9e74f0f19..6b1981c91d7252 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -963,28 +963,28 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[268] = { [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CACHE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, - [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG }, + [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_KW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [CALL_PY_WITH_DEFAULTS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1008,7 +1008,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[268] = { [END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [END_FOR] = { true, INSTR_FMT_IX, 0 }, [END_SEND] = { true, INSTR_FMT_IX, 0 }, - [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [EXTENDED_ARG] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [FORMAT_SIMPLE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1033,20 +1033,20 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[268] = { [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, + [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG }, [INSTRUMENTED_JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [INSTRUMENTED_LOAD_SUPER_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, - [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, [IS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, - [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, [JUMP_FORWARD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, [LIST_APPEND] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, @@ -1101,7 +1101,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[268] = { [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RERAISE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RESERVED] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, - [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ESCAPES_FLAG }, [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1144,7 +1144,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[268] = { [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, - [JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [JUMP_NO_INTERRUPT] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG }, [LOAD_CLOSURE] = { true, -1, HAS_ARG_FLAG | HAS_LOCAL_FLAG }, [LOAD_METHOD] = { true, -1, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index f003aaf409a2af..c56ad3d1d3aece 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -171,19 +171,19 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_INIT_CALL_PY_EXACT_ARGS] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_PUSH_FRAME] = 0, [_CALL_TYPE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, - [_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, - [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG, + [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_LEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_ISINSTANCE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -197,7 +197,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_GUARD_IS_FALSE_POP] = HAS_DEOPT_FLAG, [_GUARD_IS_NONE_POP] = HAS_DEOPT_FLAG, [_GUARD_IS_NOT_NONE_POP] = HAS_DEOPT_FLAG, - [_JUMP_TO_TOP] = 0, + [_JUMP_TO_TOP] = HAS_EVAL_BREAK_FLAG, [_SET_IP] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_SAVE_RETURN_OFFSET] = HAS_ARG_FLAG, [_EXIT_TRACE] = HAS_DEOPT_FLAG, diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index ccf5bfe261342a..392ec288585a4d 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -11,6 +11,7 @@ class Properties: deopts: bool oparg: bool jumps: bool + eval_breaker: bool ends_with_eval_breaker: bool needs_this: bool always_exits: bool @@ -34,6 +35,7 @@ def from_list(properties: list["Properties"]) -> "Properties": deopts=any(p.deopts for p in properties), oparg=any(p.oparg for p in properties), jumps=any(p.jumps for p in properties), + eval_breaker=any(p.eval_breaker for p in properties), ends_with_eval_breaker=any(p.ends_with_eval_breaker for p in properties), needs_this=any(p.needs_this for p in properties), always_exits=any(p.always_exits for p in properties), @@ -52,6 +54,7 @@ def from_list(properties: list["Properties"]) -> "Properties": deopts=False, oparg=False, jumps=False, + eval_breaker=False, ends_with_eval_breaker=False, needs_this=False, always_exits=False, @@ -344,6 +347,7 @@ def compute_properties(op: parser.InstDef) -> Properties: deopts=variable_used(op, "DEOPT_IF"), oparg=variable_used(op, "oparg"), jumps=variable_used(op, "JUMPBY"), + eval_breaker=variable_used(op, "CHECK_EVAL_BREAKER"), ends_with_eval_breaker=eval_breaker_at_end(op), needs_this=variable_used(op, "this_instr"), always_exits=always_exits(op), diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 9ad4dc525de142..e53f0d94d0bc38 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -206,6 +206,8 @@ def cflags(p: Properties) -> str: flags.append("HAS_LOCAL_FLAG") if p.deopts: flags.append("HAS_DEOPT_FLAG") + if p.eval_breaker: + flags.append("HAS_EVAL_BREAK_FLAG") if not p.infallible: flags.append("HAS_ERROR_FLAG") if p.escapes: From 7c476ced81c687dcff9e56990f06b4c631df52e2 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 17:32:55 +0000 Subject: [PATCH 29/51] Make pseudo flags union of targets and explicit flags --- .../opcode_metadata_generator.py | 18 ++++++++++-------- Tools/cases_generator/py_metadata_generator.py | 1 - 2 files changed, 10 insertions(+), 9 deletions(-) diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 7acbc240190dca..2c6e3125a68ef4 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -87,7 +87,7 @@ def emit_stack_effect_function( def generate_stack_effect_functions( analysis: Analysis, out: CWriter ) -> None: - + popped_data: list[tuple[str, str]] = [] pushed_data: list[tuple[str, str]] = [] for inst in analysis.instructions.values(): @@ -172,7 +172,7 @@ def generate_cache_table( def generate_name_table( analysis: Analysis, out: CWriter ) -> None: - table_size = 256 + len(analysis.pseudos) + table_size = 256 + len(analysis.pseudos) out.emit(f"extern const char *_PyOpcode_OpName[{table_size}];\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit(f"const char *_PyOpcode_OpName[{table_size}] = {{\n") @@ -187,7 +187,7 @@ def generate_name_table( def generate_metadata_table( analysis: Analysis, out: CWriter ) -> None: - table_size = 256 + len(analysis.pseudos) + table_size = 256 + len(analysis.pseudos) out.emit("struct opcode_metadata {\n") out.emit("uint8_t valid_entry;\n"); out.emit("int8_t instr_format;\n"); @@ -199,10 +199,12 @@ def generate_metadata_table( for inst in sorted(analysis.instructions.values(), key = lambda t:t.name): out.emit(f"[{inst.name}] = {{ true, {get_format(inst)}, {cflags(inst.properties)} }},\n") for pseudo in sorted(analysis.pseudos.values(), key = lambda t:t.name): - if pseudo.flags: - flags = " | ".join(f"{flag}_FLAG" for flag in pseudo.flags) - else: - flags = cflags(pseudo.properties) + flags = cflags(pseudo.properties) + for flag in pseudo.flags: + if flags == "0": + flags = f"{flag}_FLAG" + else: + flags += f" | {flag}_FLAG" out.emit(f"[{pseudo.name}] = {{ true, -1, {flags} }},\n") out.emit("};\n") out.emit("#endif\n\n") @@ -277,7 +279,7 @@ def generate_extra_cases( def generate_psuedo_targets( analysis: Analysis, out: CWriter ) -> None: - table_size = len(analysis.pseudos) + table_size = len(analysis.pseudos) max_targets = max(len(pseudo.targets) for pseudo in analysis.pseudos.values()) out.emit("struct pseudo_targets {\n") out.emit(f"uint8_t targets[{max_targets + 1}];\n") diff --git a/Tools/cases_generator/py_metadata_generator.py b/Tools/cases_generator/py_metadata_generator.py index d80bc419209e2a..f89f01d622c948 100644 --- a/Tools/cases_generator/py_metadata_generator.py +++ b/Tools/cases_generator/py_metadata_generator.py @@ -16,7 +16,6 @@ from generators_common import ( DEFAULT_INPUT, ROOT, - cflags, root_relative_path, get_have_arg_and_min_instrumented, ) From cecddf87c2c4b44f2f1ca5f0cce36b761e9d20a6 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 18:26:28 +0000 Subject: [PATCH 30/51] Fix handling of jumps in uops and skip specializing uops in expansions --- Include/internal/pycore_opcode_metadata.h | 11 ++++++++++- Lib/test/test_capi/test_opt.py | 2 +- Python/optimizer.c | 3 ++- Tools/cases_generator/opcode_metadata_generator.py | 9 ++++++++- 4 files changed, 21 insertions(+), 4 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index f06a2c1980b2b4..dbaf7f63d9c282 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -896,7 +896,7 @@ enum InstructionFormat { }; #define IS_VALID_OPCODE(OP) \ - (((OP) >= 0) && ((OP) < 256) && \ + (((OP) >= 0) && ((OP) < 268) && \ (_PyOpcode_opcode_metadata[(OP)].valid_entry)) #define HAS_ARG_FLAG (1) @@ -1171,6 +1171,7 @@ const struct opcode_macro_expansion _PyOpcode_macro_expansion[256] = { [BEFORE_ASYNC_WITH] = { .nuops = 1, .uops = { { _BEFORE_ASYNC_WITH, 0, 0 } } }, [BEFORE_WITH] = { .nuops = 1, .uops = { { _BEFORE_WITH, 0, 0 } } }, + [BINARY_OP] = { .nuops = 1, .uops = { { _BINARY_OP, 0, 0 } } }, [BINARY_OP_ADD_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_ADD_FLOAT, 0, 0 } } }, [BINARY_OP_ADD_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_ADD_INT, 0, 0 } } }, [BINARY_OP_ADD_UNICODE] = { .nuops = 2, .uops = { { _GUARD_BOTH_UNICODE, 0, 0 }, { _BINARY_OP_ADD_UNICODE, 0, 0 } } }, @@ -1179,6 +1180,7 @@ _PyOpcode_macro_expansion[256] = { [BINARY_OP_SUBTRACT_FLOAT] = { .nuops = 2, .uops = { { _GUARD_BOTH_FLOAT, 0, 0 }, { _BINARY_OP_SUBTRACT_FLOAT, 0, 0 } } }, [BINARY_OP_SUBTRACT_INT] = { .nuops = 2, .uops = { { _GUARD_BOTH_INT, 0, 0 }, { _BINARY_OP_SUBTRACT_INT, 0, 0 } } }, [BINARY_SLICE] = { .nuops = 1, .uops = { { _BINARY_SLICE, 0, 0 } } }, + [BINARY_SUBSCR] = { .nuops = 1, .uops = { { _BINARY_SUBSCR, 0, 0 } } }, [BINARY_SUBSCR_DICT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_DICT, 0, 0 } } }, [BINARY_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_LIST_INT, 0, 0 } } }, [BINARY_SUBSCR_STR_INT] = { .nuops = 1, .uops = { { _BINARY_SUBSCR_STR_INT, 0, 0 } } }, @@ -1209,6 +1211,7 @@ _PyOpcode_macro_expansion[256] = { [CALL_TYPE_1] = { .nuops = 1, .uops = { { _CALL_TYPE_1, 0, 0 } } }, [CHECK_EG_MATCH] = { .nuops = 1, .uops = { { _CHECK_EG_MATCH, 0, 0 } } }, [CHECK_EXC_MATCH] = { .nuops = 1, .uops = { { _CHECK_EXC_MATCH, 0, 0 } } }, + [COMPARE_OP] = { .nuops = 1, .uops = { { _COMPARE_OP, 0, 0 } } }, [COMPARE_OP_FLOAT] = { .nuops = 1, .uops = { { _COMPARE_OP_FLOAT, 0, 0 } } }, [COMPARE_OP_INT] = { .nuops = 1, .uops = { { _COMPARE_OP_INT, 0, 0 } } }, [COMPARE_OP_STR] = { .nuops = 1, .uops = { { _COMPARE_OP_STR, 0, 0 } } }, @@ -1239,6 +1242,7 @@ _PyOpcode_macro_expansion[256] = { [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND, 0, 0 } } }, [LIST_EXTEND] = { .nuops = 1, .uops = { { _LIST_EXTEND, 0, 0 } } }, [LOAD_ASSERTION_ERROR] = { .nuops = 1, .uops = { { _LOAD_ASSERTION_ERROR, 0, 0 } } }, + [LOAD_ATTR] = { .nuops = 1, .uops = { { _LOAD_ATTR, 8, 0 } } }, [LOAD_ATTR_CLASS] = { .nuops = 2, .uops = { { _CHECK_ATTR_CLASS, 2, 1 }, { _LOAD_ATTR_CLASS, 4, 5 } } }, [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES, 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE, 1, 3 } } }, [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT, 0, 0 }, { _LOAD_ATTR_METHOD_LAZY_DICT, 4, 5 } } }, @@ -1258,6 +1262,7 @@ _PyOpcode_macro_expansion[256] = { [LOAD_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _LOAD_FAST, 5, 0 }, { _LOAD_FAST, 6, 0 } } }, [LOAD_FROM_DICT_OR_DEREF] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF, 0, 0 } } }, [LOAD_FROM_DICT_OR_GLOBALS] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_GLOBALS, 0, 0 } } }, + [LOAD_GLOBAL] = { .nuops = 1, .uops = { { _LOAD_GLOBAL, 3, 0 } } }, [LOAD_GLOBAL_BUILTIN] = { .nuops = 3, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _GUARD_BUILTINS_VERSION, 1, 2 }, { _LOAD_GLOBAL_BUILTINS, 1, 3 } } }, [LOAD_GLOBAL_MODULE] = { .nuops = 2, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _LOAD_GLOBAL_MODULE, 1, 3 } } }, [LOAD_LOCALS] = { .nuops = 1, .uops = { { _LOAD_LOCALS, 0, 0 } } }, @@ -1283,6 +1288,7 @@ _PyOpcode_macro_expansion[256] = { [SET_ADD] = { .nuops = 1, .uops = { { _SET_ADD, 0, 0 } } }, [SET_FUNCTION_ATTRIBUTE] = { .nuops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE, 0, 0 } } }, [SET_UPDATE] = { .nuops = 1, .uops = { { _SET_UPDATE, 0, 0 } } }, + [STORE_ATTR] = { .nuops = 1, .uops = { { _STORE_ATTR, 3, 0 } } }, [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES, 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE, 1, 3 } } }, [STORE_ATTR_SLOT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _STORE_ATTR_SLOT, 1, 3 } } }, [STORE_DEREF] = { .nuops = 1, .uops = { { _STORE_DEREF, 0, 0 } } }, @@ -1292,9 +1298,11 @@ _PyOpcode_macro_expansion[256] = { [STORE_GLOBAL] = { .nuops = 1, .uops = { { _STORE_GLOBAL, 0, 0 } } }, [STORE_NAME] = { .nuops = 1, .uops = { { _STORE_NAME, 0, 0 } } }, [STORE_SLICE] = { .nuops = 1, .uops = { { _STORE_SLICE, 0, 0 } } }, + [STORE_SUBSCR] = { .nuops = 1, .uops = { { _STORE_SUBSCR, 0, 0 } } }, [STORE_SUBSCR_DICT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_DICT, 0, 0 } } }, [STORE_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_LIST_INT, 0, 0 } } }, [SWAP] = { .nuops = 1, .uops = { { _SWAP, 0, 0 } } }, + [TO_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL, 2, 0 } } }, [TO_BOOL_ALWAYS_TRUE] = { .nuops = 1, .uops = { { _TO_BOOL_ALWAYS_TRUE, 2, 1 } } }, [TO_BOOL_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL_BOOL, 0, 0 } } }, [TO_BOOL_INT] = { .nuops = 1, .uops = { { _TO_BOOL_INT, 0, 0 } } }, @@ -1305,6 +1313,7 @@ _PyOpcode_macro_expansion[256] = { [UNARY_NEGATIVE] = { .nuops = 1, .uops = { { _UNARY_NEGATIVE, 0, 0 } } }, [UNARY_NOT] = { .nuops = 1, .uops = { { _UNARY_NOT, 0, 0 } } }, [UNPACK_EX] = { .nuops = 1, .uops = { { _UNPACK_EX, 0, 0 } } }, + [UNPACK_SEQUENCE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE, 0, 0 } } }, [UNPACK_SEQUENCE_LIST] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_LIST, 0, 0 } } }, [UNPACK_SEQUENCE_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TUPLE, 0, 0 } } }, [UNPACK_SEQUENCE_TWO_TUPLE] = { .nuops = 1, .uops = { { _UNPACK_SEQUENCE_TWO_TUPLE, 0, 0 } } }, diff --git a/Lib/test/test_capi/test_opt.py b/Lib/test/test_capi/test_opt.py index 9f4731103c9413..e1eb23cecd68d9 100644 --- a/Lib/test/test_capi/test_opt.py +++ b/Lib/test/test_capi/test_opt.py @@ -243,7 +243,7 @@ def many_vars(): ex = get_first_executor(many_vars) self.assertIsNotNone(ex) - self.assertIn(("LOAD_FAST", 259, 0), list(ex)) + self.assertIn(("_LOAD_FAST", 259, 0), list(ex)) def test_unspecialized_unpack(self): # An example of an unspecialized opcode diff --git a/Python/optimizer.c b/Python/optimizer.c index 607fa33bb4760d..6ab596d8b2c710 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -803,7 +803,8 @@ compute_used(_PyUOpInstruction *buffer, uint32_t *used) } /* All other micro-ops fall through, so i+1 is reachable */ SET_BIT(used, i+1); - if (OPCODE_HAS_JUMP(opcode)) { + assert(opcode <= MAX_UOP_ID); + if (_PyUop_Flags[opcode] & HAS_JUMP_FLAG) { /* Mark target as reachable */ SET_BIT(used, buffer[i].oparg); } diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 2c6e3125a68ef4..6d104a567594d5 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -237,6 +237,9 @@ def generate_expansion_table( if part.name == "_SAVE_RETURN_OFFSET": size = OPARG_SIZES["OPARG_SAVE_RETURN_OFFSET"] if isinstance(part, Uop): + # Skip specializations + if "specializing" in part.annotations: + continue expansions.append((part.name, size, offset if size else 0)) offset += part.size expansions_table[inst.name] = expansions @@ -260,6 +263,9 @@ def is_viable_expansion(inst: Instruction) -> bool: "An instruction can be expanded if all its parts are viable for tier 2" for part in inst.parts: if isinstance(part, Uop): + # Skip specializations + if "specializing" in part.annotations: + continue if part.properties.tier_one_only or not part.is_viable(): return False return True @@ -321,8 +327,9 @@ def generate_opcode_metadata( out.emit('#include "pycore_uop_ids.h"\n') generate_stack_effect_functions(analysis, out) generate_instruction_formats(analysis, out) + table_size = 256 + len(analysis.pseudos) out.emit("#define IS_VALID_OPCODE(OP) \\\n") - out.emit(" (((OP) >= 0) && ((OP) < 256) && \\\n") + out.emit(f" (((OP) >= 0) && ((OP) < {table_size}) && \\\n") out.emit(" (_PyOpcode_opcode_metadata[(OP)].valid_entry))\n\n") generate_flag_macros(out) generate_oparg_macros(out) From 05a48eca148c3b8043538ca2d5610c2fa5ae813b Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 19:03:36 +0000 Subject: [PATCH 31/51] Reject unused cache entries in ops --- Include/internal/pycore_opcode_metadata.h | 8 ++--- Python/bytecodes.c | 40 ++++++++++++++--------- Python/generated_cases.c.h | 11 +++++++ Tools/cases_generator/analyzer.py | 7 +++- 4 files changed, 45 insertions(+), 21 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index dbaf7f63d9c282..60daa40d2e0f7d 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1242,7 +1242,7 @@ _PyOpcode_macro_expansion[256] = { [LIST_APPEND] = { .nuops = 1, .uops = { { _LIST_APPEND, 0, 0 } } }, [LIST_EXTEND] = { .nuops = 1, .uops = { { _LIST_EXTEND, 0, 0 } } }, [LOAD_ASSERTION_ERROR] = { .nuops = 1, .uops = { { _LOAD_ASSERTION_ERROR, 0, 0 } } }, - [LOAD_ATTR] = { .nuops = 1, .uops = { { _LOAD_ATTR, 8, 0 } } }, + [LOAD_ATTR] = { .nuops = 1, .uops = { { _LOAD_ATTR, 0, 0 } } }, [LOAD_ATTR_CLASS] = { .nuops = 2, .uops = { { _CHECK_ATTR_CLASS, 2, 1 }, { _LOAD_ATTR_CLASS, 4, 5 } } }, [LOAD_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_MANAGED_OBJECT_HAS_VALUES, 0, 0 }, { _LOAD_ATTR_INSTANCE_VALUE, 1, 3 } } }, [LOAD_ATTR_METHOD_LAZY_DICT] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _CHECK_ATTR_METHOD_LAZY_DICT, 0, 0 }, { _LOAD_ATTR_METHOD_LAZY_DICT, 4, 5 } } }, @@ -1262,7 +1262,7 @@ _PyOpcode_macro_expansion[256] = { [LOAD_FAST_LOAD_FAST] = { .nuops = 2, .uops = { { _LOAD_FAST, 5, 0 }, { _LOAD_FAST, 6, 0 } } }, [LOAD_FROM_DICT_OR_DEREF] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_DEREF, 0, 0 } } }, [LOAD_FROM_DICT_OR_GLOBALS] = { .nuops = 1, .uops = { { _LOAD_FROM_DICT_OR_GLOBALS, 0, 0 } } }, - [LOAD_GLOBAL] = { .nuops = 1, .uops = { { _LOAD_GLOBAL, 3, 0 } } }, + [LOAD_GLOBAL] = { .nuops = 1, .uops = { { _LOAD_GLOBAL, 0, 0 } } }, [LOAD_GLOBAL_BUILTIN] = { .nuops = 3, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _GUARD_BUILTINS_VERSION, 1, 2 }, { _LOAD_GLOBAL_BUILTINS, 1, 3 } } }, [LOAD_GLOBAL_MODULE] = { .nuops = 2, .uops = { { _GUARD_GLOBALS_VERSION, 1, 1 }, { _LOAD_GLOBAL_MODULE, 1, 3 } } }, [LOAD_LOCALS] = { .nuops = 1, .uops = { { _LOAD_LOCALS, 0, 0 } } }, @@ -1288,7 +1288,7 @@ _PyOpcode_macro_expansion[256] = { [SET_ADD] = { .nuops = 1, .uops = { { _SET_ADD, 0, 0 } } }, [SET_FUNCTION_ATTRIBUTE] = { .nuops = 1, .uops = { { _SET_FUNCTION_ATTRIBUTE, 0, 0 } } }, [SET_UPDATE] = { .nuops = 1, .uops = { { _SET_UPDATE, 0, 0 } } }, - [STORE_ATTR] = { .nuops = 1, .uops = { { _STORE_ATTR, 3, 0 } } }, + [STORE_ATTR] = { .nuops = 1, .uops = { { _STORE_ATTR, 0, 0 } } }, [STORE_ATTR_INSTANCE_VALUE] = { .nuops = 3, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _GUARD_DORV_VALUES, 0, 0 }, { _STORE_ATTR_INSTANCE_VALUE, 1, 3 } } }, [STORE_ATTR_SLOT] = { .nuops = 2, .uops = { { _GUARD_TYPE_VERSION, 2, 1 }, { _STORE_ATTR_SLOT, 1, 3 } } }, [STORE_DEREF] = { .nuops = 1, .uops = { { _STORE_DEREF, 0, 0 } } }, @@ -1302,7 +1302,7 @@ _PyOpcode_macro_expansion[256] = { [STORE_SUBSCR_DICT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_DICT, 0, 0 } } }, [STORE_SUBSCR_LIST_INT] = { .nuops = 1, .uops = { { _STORE_SUBSCR_LIST_INT, 0, 0 } } }, [SWAP] = { .nuops = 1, .uops = { { _SWAP, 0, 0 } } }, - [TO_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL, 2, 0 } } }, + [TO_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL, 0, 0 } } }, [TO_BOOL_ALWAYS_TRUE] = { .nuops = 1, .uops = { { _TO_BOOL_ALWAYS_TRUE, 2, 1 } } }, [TO_BOOL_BOOL] = { .nuops = 1, .uops = { { _TO_BOOL_BOOL, 0, 0 } } }, [TO_BOOL_INT] = { .nuops = 1, .uops = { { _TO_BOOL_INT, 0, 0 } } }, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 0890677b7d2460..b131b86a040fd2 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -330,14 +330,14 @@ dummy_func( #endif /* ENABLE_SPECIALIZATION */ } - op(_TO_BOOL, (unused/2, value -- res)) { + op(_TO_BOOL, (value -- res)) { int err = PyObject_IsTrue(value); DECREF_INPUTS(); ERROR_IF(err < 0, error); res = err ? Py_True : Py_False; } - macro(TO_BOOL) = _SPECIALIZE_TO_BOOL + _TO_BOOL; + macro(TO_BOOL) = _SPECIALIZE_TO_BOOL + unused/2 + _TO_BOOL; inst(TO_BOOL_BOOL, (unused/1, unused/2, value -- value)) { DEOPT_IF(!PyBool_Check(value)); @@ -1295,14 +1295,14 @@ dummy_func( #endif /* ENABLE_SPECIALIZATION */ } - op(_STORE_ATTR, (unused/3, v, owner --)) { + op(_STORE_ATTR, (v, owner --)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); int err = PyObject_SetAttr(owner, name, v); DECREF_INPUTS(); ERROR_IF(err, error); } - macro(STORE_ATTR) = _SPECIALIZE_STORE_ATTR + _STORE_ATTR; + macro(STORE_ATTR) = _SPECIALIZE_STORE_ATTR + unused/3 + _STORE_ATTR; inst(DELETE_ATTR, (owner --)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); @@ -1414,7 +1414,7 @@ dummy_func( #endif /* ENABLE_SPECIALIZATION */ } - op(_LOAD_GLOBAL, (unused/1, unused/1, unused/1 -- res, null if (oparg & 1))) { + op(_LOAD_GLOBAL, ( -- res, null if (oparg & 1))) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); if (PyDict_CheckExact(GLOBALS()) && PyDict_CheckExact(BUILTINS())) @@ -1451,7 +1451,12 @@ dummy_func( null = NULL; } - macro(LOAD_GLOBAL) = _SPECIALIZE_LOAD_GLOBAL + _LOAD_GLOBAL; + macro(LOAD_GLOBAL) = + _SPECIALIZE_LOAD_GLOBAL + + unused/1 + + unused/1 + + unused/1 + + _LOAD_GLOBAL; op(_GUARD_GLOBALS_VERSION, (version/1 --)) { PyDictObject *dict = (PyDictObject *)GLOBALS(); @@ -1853,7 +1858,7 @@ dummy_func( #endif /* ENABLE_SPECIALIZATION */ } - op(_LOAD_ATTR, (unused/8, owner -- attr, self_or_null if (oparg & 1))) { + op(_LOAD_ATTR, (owner -- attr, self_or_null if (oparg & 1))) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 1); if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ @@ -1886,7 +1891,10 @@ dummy_func( } } - macro(LOAD_ATTR) = _SPECIALIZE_LOAD_ATTR + _LOAD_ATTR; + macro(LOAD_ATTR) = + _SPECIALIZE_LOAD_ATTR + + unused/8 + + _LOAD_ATTR; pseudo(LOAD_METHOD) = { LOAD_ATTR, @@ -2369,7 +2377,7 @@ dummy_func( stack_pointer = _PyFrame_GetStackPointer(frame); } - replaced op(_POP_JUMP_IF_FALSE, (unused/1, cond -- )) { + replaced op(_POP_JUMP_IF_FALSE, (cond -- )) { assert(PyBool_Check(cond)); int flag = Py_IsFalse(cond); #if ENABLE_SPECIALIZATION @@ -2378,7 +2386,7 @@ dummy_func( JUMPBY(oparg * flag); } - replaced op(_POP_JUMP_IF_TRUE, (unused/1, cond -- )) { + replaced op(_POP_JUMP_IF_TRUE, (cond -- )) { assert(PyBool_Check(cond)); int flag = Py_IsTrue(cond); #if ENABLE_SPECIALIZATION @@ -2397,13 +2405,13 @@ dummy_func( } } - macro(POP_JUMP_IF_TRUE) = _POP_JUMP_IF_TRUE; + macro(POP_JUMP_IF_TRUE) = unused/1 + _POP_JUMP_IF_TRUE; - macro(POP_JUMP_IF_FALSE) = _POP_JUMP_IF_FALSE; + macro(POP_JUMP_IF_FALSE) = unused/1 + _POP_JUMP_IF_FALSE; - macro(POP_JUMP_IF_NONE) = _IS_NONE + _POP_JUMP_IF_TRUE; + macro(POP_JUMP_IF_NONE) = unused/1 + _IS_NONE + _POP_JUMP_IF_TRUE; - macro(POP_JUMP_IF_NOT_NONE) = _IS_NONE + _POP_JUMP_IF_FALSE; + macro(POP_JUMP_IF_NOT_NONE) = unused/1 + _IS_NONE + _POP_JUMP_IF_FALSE; inst(JUMP_BACKWARD_NO_INTERRUPT, (--)) { TIER_ONE_ONLY @@ -3010,7 +3018,7 @@ dummy_func( } // When calling Python, inline the call using DISPATCH_INLINED(). - op(_CALL, (unused/2, callable, self_or_null, args[oparg] -- res)) { + op(_CALL, (callable, self_or_null, args[oparg] -- res)) { // oparg counts all of the args, but *not* self: int total_args = oparg; if (self_or_null != NULL) { @@ -3079,7 +3087,7 @@ dummy_func( CHECK_EVAL_BREAKER(); } - macro(CALL) = _SPECIALIZE_CALL + _CALL; + macro(CALL) = _SPECIALIZE_CALL + unused/2 + _CALL; op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null, unused[oparg] -- callable, null, unused[oparg])) { DEOPT_IF(null != NULL); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index a8c6db51bc5abf..e935f33fa2131a 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -771,6 +771,7 @@ DECREMENT_ADAPTIVE_COUNTER(this_instr[1].cache); #endif /* ENABLE_SPECIALIZATION */ } + /* Skip 2 cache entries */ // _CALL { // oparg counts all of the args, but *not* self: @@ -3408,6 +3409,7 @@ DECREMENT_ADAPTIVE_COUNTER(this_instr[1].cache); #endif /* ENABLE_SPECIALIZATION */ } + /* Skip 8 cache entries */ // _LOAD_ATTR { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 1); @@ -4104,6 +4106,9 @@ DECREMENT_ADAPTIVE_COUNTER(this_instr[1].cache); #endif /* ENABLE_SPECIALIZATION */ } + /* Skip 1 cache entry */ + /* Skip 1 cache entry */ + /* Skip 1 cache entry */ // _LOAD_GLOBAL { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); @@ -4572,6 +4577,7 @@ next_instr += 2; INSTRUCTION_STATS(POP_JUMP_IF_FALSE); PyObject *cond; + /* Skip 1 cache entry */ cond = stack_pointer[-1]; assert(PyBool_Check(cond)); int flag = Py_IsFalse(cond); @@ -4590,6 +4596,7 @@ PyObject *value; PyObject *b; PyObject *cond; + /* Skip 1 cache entry */ // _IS_NONE value = stack_pointer[-1]; { @@ -4622,6 +4629,7 @@ PyObject *value; PyObject *b; PyObject *cond; + /* Skip 1 cache entry */ // _IS_NONE value = stack_pointer[-1]; { @@ -4652,6 +4660,7 @@ next_instr += 2; INSTRUCTION_STATS(POP_JUMP_IF_TRUE); PyObject *cond; + /* Skip 1 cache entry */ cond = stack_pointer[-1]; assert(PyBool_Check(cond)); int flag = Py_IsTrue(cond); @@ -5125,6 +5134,7 @@ DECREMENT_ADAPTIVE_COUNTER(this_instr[1].cache); #endif /* ENABLE_SPECIALIZATION */ } + /* Skip 3 cache entries */ // _STORE_ATTR v = stack_pointer[-2]; { @@ -5517,6 +5527,7 @@ DECREMENT_ADAPTIVE_COUNTER(this_instr[1].cache); #endif /* ENABLE_SPECIALIZATION */ } + /* Skip 2 cache entries */ // _TO_BOOL { int err = PyObject_IsTrue(value); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index d3493972151b53..d7b22f30ed8afe 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -239,7 +239,7 @@ class Analysis: def analysis_error(message: str, tkn: lexer.Token) -> SyntaxError: # To do -- support file and line output # Construct a SyntaxError instance from message and token - return lexer.make_syntax_error(message, "", tkn.line, tkn.column, "") + return lexer.make_syntax_error(message, tkn.filename, tkn.line, tkn.column, "") def override_error( @@ -274,6 +274,11 @@ def analyze_caches(inputs: list[parser.InputEffect]) -> list[CacheEntry]: caches: list[parser.CacheEffect] = [ i for i in inputs if isinstance(i, parser.CacheEffect) ] + for cache in caches: + if cache.name == "unused": + raise analysis_error( + "Unused cache entry in op. Move to enclosing macro.", + cache.tokens[0]) return [CacheEntry(i.name, int(i.size)) for i in caches] From 9c10d7ce6945dd104935a2e01d38dea4e9e12fd6 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 19:24:07 +0000 Subject: [PATCH 32/51] Only emit caches sizes for non-specialized instructions --- Include/internal/pycore_opcode_metadata.h | 77 ------------------- Python/bytecodes.c | 2 +- Python/generated_cases.c.h | 2 +- .../opcode_metadata_generator.py | 4 + 4 files changed, 6 insertions(+), 79 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 60daa40d2e0f7d..0231925307e043 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1550,100 +1550,23 @@ const char *_PyOpcode_OpName[268] = { extern const uint8_t _PyOpcode_Caches[256]; #ifdef NEED_OPCODE_METADATA const uint8_t _PyOpcode_Caches[256] = { - [TO_BOOL_BOOL] = 3, - [TO_BOOL_INT] = 3, - [TO_BOOL_LIST] = 3, - [TO_BOOL_NONE] = 3, - [TO_BOOL_STR] = 3, - [TO_BOOL_ALWAYS_TRUE] = 3, - [BINARY_SUBSCR_LIST_INT] = 1, - [BINARY_SUBSCR_STR_INT] = 1, - [BINARY_SUBSCR_TUPLE_INT] = 1, - [BINARY_SUBSCR_DICT] = 1, - [BINARY_SUBSCR_GETITEM] = 1, - [STORE_SUBSCR_LIST_INT] = 1, - [STORE_SUBSCR_DICT] = 1, - [SEND_GEN] = 1, - [UNPACK_SEQUENCE_TWO_TUPLE] = 1, - [UNPACK_SEQUENCE_TUPLE] = 1, - [UNPACK_SEQUENCE_LIST] = 1, - [INSTRUMENTED_LOAD_SUPER_ATTR] = 1, - [LOAD_SUPER_ATTR_ATTR] = 1, - [LOAD_SUPER_ATTR_METHOD] = 1, - [LOAD_ATTR_PROPERTY] = 9, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = 9, - [STORE_ATTR_WITH_HINT] = 4, - [COMPARE_OP_FLOAT] = 1, - [COMPARE_OP_INT] = 1, - [COMPARE_OP_STR] = 1, [JUMP_BACKWARD] = 1, - [INSTRUMENTED_FOR_ITER] = 1, - [FOR_ITER_GEN] = 1, - [INSTRUMENTED_CALL] = 3, - [CALL_PY_WITH_DEFAULTS] = 3, - [CALL_TYPE_1] = 3, - [CALL_STR_1] = 3, - [CALL_TUPLE_1] = 3, - [CALL_ALLOC_AND_ENTER_INIT] = 3, - [CALL_BUILTIN_CLASS] = 3, - [CALL_BUILTIN_O] = 3, - [CALL_BUILTIN_FAST] = 3, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = 3, - [CALL_LEN] = 3, - [CALL_ISINSTANCE] = 3, - [CALL_LIST_APPEND] = 3, - [CALL_METHOD_DESCRIPTOR_O] = 3, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = 3, - [CALL_METHOD_DESCRIPTOR_NOARGS] = 3, - [CALL_METHOD_DESCRIPTOR_FAST] = 3, - [INSTRUMENTED_JUMP_BACKWARD] = 1, - [INSTRUMENTED_POP_JUMP_IF_TRUE] = 1, - [INSTRUMENTED_POP_JUMP_IF_FALSE] = 1, - [INSTRUMENTED_POP_JUMP_IF_NONE] = 1, - [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = 1, [TO_BOOL] = 3, - [BINARY_OP_MULTIPLY_INT] = 1, - [BINARY_OP_ADD_INT] = 1, - [BINARY_OP_SUBTRACT_INT] = 1, - [BINARY_OP_MULTIPLY_FLOAT] = 1, - [BINARY_OP_ADD_FLOAT] = 1, - [BINARY_OP_SUBTRACT_FLOAT] = 1, - [BINARY_OP_ADD_UNICODE] = 1, - [BINARY_OP_INPLACE_ADD_UNICODE] = 1, [BINARY_SUBSCR] = 1, [STORE_SUBSCR] = 1, [SEND] = 1, [UNPACK_SEQUENCE] = 1, [STORE_ATTR] = 4, [LOAD_GLOBAL] = 4, - [LOAD_GLOBAL_MODULE] = 4, - [LOAD_GLOBAL_BUILTIN] = 4, [LOAD_SUPER_ATTR] = 1, [LOAD_ATTR] = 9, - [LOAD_ATTR_INSTANCE_VALUE] = 9, - [LOAD_ATTR_MODULE] = 9, - [LOAD_ATTR_WITH_HINT] = 9, - [LOAD_ATTR_SLOT] = 9, - [LOAD_ATTR_CLASS] = 9, - [STORE_ATTR_INSTANCE_VALUE] = 4, - [STORE_ATTR_SLOT] = 4, [COMPARE_OP] = 1, [POP_JUMP_IF_TRUE] = 1, [POP_JUMP_IF_FALSE] = 1, [POP_JUMP_IF_NONE] = 1, [POP_JUMP_IF_NOT_NONE] = 1, [FOR_ITER] = 1, - [FOR_ITER_LIST] = 1, - [FOR_ITER_TUPLE] = 1, - [FOR_ITER_RANGE] = 1, - [LOAD_ATTR_METHOD_WITH_VALUES] = 9, - [LOAD_ATTR_METHOD_NO_DICT] = 9, - [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = 9, - [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = 9, - [LOAD_ATTR_METHOD_LAZY_DICT] = 9, [CALL] = 3, - [CALL_BOUND_METHOD_EXACT_ARGS] = 3, - [CALL_PY_EXACT_ARGS] = 3, [BINARY_OP] = 1, }; #endif diff --git a/Python/bytecodes.c b/Python/bytecodes.c index b131b86a040fd2..76765885fe2337 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -2312,7 +2312,7 @@ dummy_func( JUMPBY(oparg); } - inst(JUMP_BACKWARD, (unused/1 --)) { + inst(JUMP_BACKWARD, (counter/1 --)) { CHECK_EVAL_BREAKER(); assert(oparg <= INSTR_OFFSET()); JUMPBY(-oparg); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index e935f33fa2131a..65ff3310fa0623 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -3273,7 +3273,7 @@ _Py_CODEUNIT *this_instr = frame->instr_ptr = next_instr; next_instr += 2; INSTRUCTION_STATS(JUMP_BACKWARD); - /* Skip 1 cache entry */ + uint16_t counter = read_u16(&this_instr[1].cache); CHECK_EVAL_BREAKER(); assert(oparg <= INSTR_OFFSET()); JUMPBY(-oparg); diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 6d104a567594d5..54a2210a461d75 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -163,6 +163,10 @@ def generate_cache_table( out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const uint8_t _PyOpcode_Caches[256] = {\n") for inst in analysis.instructions.values(): + if inst.family and inst.family.name != inst.name: + continue + if inst.name.startswith("INSTRUMENTED"): + continue if inst.size > 1: out.emit(f"[{inst.name}] = {inst.size-1},\n") out.emit("};\n") From 062c7c1d3c59b50590b64ad64e08677005c78223 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 19:28:49 +0000 Subject: [PATCH 33/51] Keep flag order the same --- Include/internal/pycore_opcode_metadata.h | 20 ++++++++++---------- Include/internal/pycore_uop_metadata.h | 20 ++++++++++---------- Tools/cases_generator/generators_common.py | 4 ++-- 3 files changed, 22 insertions(+), 22 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 0231925307e043..01b33a118b1a65 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -966,10 +966,10 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[268] = { [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG }, - [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, + [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -977,14 +977,14 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[268] = { [CALL_KW] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_NOARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, [CALL_PY_WITH_DEFAULTS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, - [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index c56ad3d1d3aece..300bd3baa7b377 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -171,19 +171,19 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_INIT_CALL_PY_EXACT_ARGS] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_PUSH_FRAME] = 0, [_CALL_TYPE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, - [_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_STR_1] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG, - [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, + [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_LEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_ISINSTANCE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, [_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index e53f0d94d0bc38..f59e007b4e67b4 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -204,10 +204,10 @@ def cflags(p: Properties) -> str: flags.append("HAS_FREE_FLAG") if p.uses_locals: flags.append("HAS_LOCAL_FLAG") - if p.deopts: - flags.append("HAS_DEOPT_FLAG") if p.eval_breaker: flags.append("HAS_EVAL_BREAK_FLAG") + if p.deopts: + flags.append("HAS_DEOPT_FLAG") if not p.infallible: flags.append("HAS_ERROR_FLAG") if p.escapes: From 436ad9b61ff4ecb6e057bf1c4804b1561ef78dac Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 19:37:02 +0000 Subject: [PATCH 34/51] Revert counter to unused --- Python/bytecodes.c | 2 +- Python/generated_cases.c.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 76765885fe2337..b131b86a040fd2 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -2312,7 +2312,7 @@ dummy_func( JUMPBY(oparg); } - inst(JUMP_BACKWARD, (counter/1 --)) { + inst(JUMP_BACKWARD, (unused/1 --)) { CHECK_EVAL_BREAKER(); assert(oparg <= INSTR_OFFSET()); JUMPBY(-oparg); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 65ff3310fa0623..e935f33fa2131a 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -3273,7 +3273,7 @@ _Py_CODEUNIT *this_instr = frame->instr_ptr = next_instr; next_instr += 2; INSTRUCTION_STATS(JUMP_BACKWARD); - uint16_t counter = read_u16(&this_instr[1].cache); + /* Skip 1 cache entry */ CHECK_EVAL_BREAKER(); assert(oparg <= INSTR_OFFSET()); JUMPBY(-oparg); From 495915e6d002b260ee1fcdfe16c018dda7f4a739 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 20:12:00 +0000 Subject: [PATCH 35/51] Mark replaced uops in expansion table --- Include/internal/pycore_opcode_metadata.h | 9 +++++++++ Lib/test/test_capi/test_opt.py | 3 ++- Python/optimizer.c | 18 +++++++++--------- .../opcode_metadata_generator.py | 8 +++++++- 4 files changed, 27 insertions(+), 11 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 01b33a118b1a65..a9e0cd1238929f 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -927,6 +927,7 @@ enum InstructionFormat { #define OPARG_TOP 5 #define OPARG_BOTTOM 6 #define OPARG_SAVE_RETURN_OFFSET 7 +#define OPARG_REPLACED 9 struct opcode_metadata { uint8_t valid_entry; @@ -1232,6 +1233,10 @@ _PyOpcode_macro_expansion[256] = { [EXIT_INIT_CHECK] = { .nuops = 1, .uops = { { _EXIT_INIT_CHECK, 0, 0 } } }, [FORMAT_SIMPLE] = { .nuops = 1, .uops = { { _FORMAT_SIMPLE, 0, 0 } } }, [FORMAT_WITH_SPEC] = { .nuops = 1, .uops = { { _FORMAT_WITH_SPEC, 0, 0 } } }, + [FOR_ITER] = { .nuops = 1, .uops = { { _FOR_ITER, 9, 0 } } }, + [FOR_ITER_LIST] = { .nuops = 3, .uops = { { _ITER_CHECK_LIST, 0, 0 }, { _ITER_JUMP_LIST, 9, 1 }, { _ITER_NEXT_LIST, 0, 0 } } }, + [FOR_ITER_RANGE] = { .nuops = 3, .uops = { { _ITER_CHECK_RANGE, 0, 0 }, { _ITER_JUMP_RANGE, 9, 1 }, { _ITER_NEXT_RANGE, 0, 0 } } }, + [FOR_ITER_TUPLE] = { .nuops = 3, .uops = { { _ITER_CHECK_TUPLE, 0, 0 }, { _ITER_JUMP_TUPLE, 9, 1 }, { _ITER_NEXT_TUPLE, 0, 0 } } }, [GET_AITER] = { .nuops = 1, .uops = { { _GET_AITER, 0, 0 } } }, [GET_ANEXT] = { .nuops = 1, .uops = { { _GET_ANEXT, 0, 0 } } }, [GET_AWAITABLE] = { .nuops = 1, .uops = { { _GET_AWAITABLE, 0, 0 } } }, @@ -1278,6 +1283,10 @@ _PyOpcode_macro_expansion[256] = { [MATCH_SEQUENCE] = { .nuops = 1, .uops = { { _MATCH_SEQUENCE, 0, 0 } } }, [NOP] = { .nuops = 1, .uops = { { _NOP, 0, 0 } } }, [POP_EXCEPT] = { .nuops = 1, .uops = { { _POP_EXCEPT, 0, 0 } } }, + [POP_JUMP_IF_FALSE] = { .nuops = 1, .uops = { { _POP_JUMP_IF_FALSE, 9, 1 } } }, + [POP_JUMP_IF_NONE] = { .nuops = 2, .uops = { { _IS_NONE, 0, 0 }, { _POP_JUMP_IF_TRUE, 9, 1 } } }, + [POP_JUMP_IF_NOT_NONE] = { .nuops = 2, .uops = { { _IS_NONE, 0, 0 }, { _POP_JUMP_IF_FALSE, 9, 1 } } }, + [POP_JUMP_IF_TRUE] = { .nuops = 1, .uops = { { _POP_JUMP_IF_TRUE, 9, 1 } } }, [POP_TOP] = { .nuops = 1, .uops = { { _POP_TOP, 0, 0 } } }, [PUSH_EXC_INFO] = { .nuops = 1, .uops = { { _PUSH_EXC_INFO, 0, 0 } } }, [PUSH_NULL] = { .nuops = 1, .uops = { { _PUSH_NULL, 0, 0 } } }, diff --git a/Lib/test/test_capi/test_opt.py b/Lib/test/test_capi/test_opt.py index e1eb23cecd68d9..5c8c0596610303 100644 --- a/Lib/test/test_capi/test_opt.py +++ b/Lib/test/test_capi/test_opt.py @@ -176,6 +176,7 @@ def f(): with temporary_optimizer(opt): f() exe = get_first_executor(f) + self.assertIsNotNone(exe) self.assertTrue(exe.is_valid()) _testinternalcapi.invalidate_executors(f.__code__) self.assertFalse(exe.is_valid()) @@ -196,7 +197,7 @@ def testfunc(x): self.assertIsNotNone(ex) uops = {opname for opname, _, _ in ex} self.assertIn("_SET_IP", uops) - self.assertIn("LOAD_FAST", uops) + self.assertIn("_LOAD_FAST", uops) def test_extended_arg(self): "Check EXTENDED_ARG handling in superblock creation" diff --git a/Python/optimizer.c b/Python/optimizer.c index 6ab596d8b2c710..e53f9c7387e7fe 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -633,14 +633,6 @@ translate_bytecode_to_trace( oparg += extras; } } - if (_PyUOp_Replacements[uop]) { - uop = _PyUOp_Replacements[uop]; - if (uop == _FOR_ITER_TIER_TWO) { - target += 1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1; - assert(_PyCode_CODE(code)[target-1].op.code == END_FOR || - _PyCode_CODE(code)[target-1].op.code == INSTRUMENTED_END_FOR); - } - } break; case OPARG_CACHE_1: operand = read_u16(&instr[offset].cache); @@ -661,7 +653,15 @@ translate_bytecode_to_trace( oparg = offset; assert(uop == _SAVE_RETURN_OFFSET); break; - + case OPARG_REPLACED: + uop = _PyUOp_Replacements[uop]; + assert(uop != 0); + if (uop == _FOR_ITER_TIER_TWO) { + target += 1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg + 1; + assert(_PyCode_CODE(code)[target-1].op.code == END_FOR || + _PyCode_CODE(code)[target-1].op.code == INSTRUMENTED_END_FOR); + } + break; default: fprintf(stderr, "opcode=%d, oparg=%d; nuops=%d, i=%d; size=%d, offset=%d\n", diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 54a2210a461d75..d080a4a859e547 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -35,6 +35,8 @@ "OPARG_TOP": 5, "OPARG_BOTTOM": 6, "OPARG_SAVE_RETURN_OFFSET": 7, + # Skip 8 as the other powers of 2 are sizes + "OPARG_REPLACED": 9 } @@ -244,6 +246,8 @@ def generate_expansion_table( # Skip specializations if "specializing" in part.annotations: continue + if "replaced" in part.annotations: + size = OPARG_SIZES["OPARG_REPLACED"] expansions.append((part.name, size, offset if size else 0)) offset += part.size expansions_table[inst.name] = expansions @@ -267,9 +271,11 @@ def is_viable_expansion(inst: Instruction) -> bool: "An instruction can be expanded if all its parts are viable for tier 2" for part in inst.parts: if isinstance(part, Uop): - # Skip specializations + # Skip specializing and replaced uops if "specializing" in part.annotations: continue + if "replaced" in part.annotations: + continue if part.properties.tier_one_only or not part.is_viable(): return False return True From 39f070d91729dce2bb494297a6a981440bd5a909 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 20:52:34 +0000 Subject: [PATCH 36/51] Keep the tools happy --- Tools/cases_generator/generators_common.py | 1 - Tools/cases_generator/opcode_metadata_generator.py | 2 +- Tools/cases_generator/stack.py | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index f59e007b4e67b4..fcac8d1a57760a 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -231,4 +231,3 @@ def get_have_arg_and_min_instrumented(analysis: Analysis) -> tuple[int, int]: if analysis.instructions[name].properties.oparg and op < first_arg: first_arg = op return first_arg, min_instrumented - diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index d080a4a859e547..a97b84f50c662c 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -263,7 +263,7 @@ def generate_expansion_table( out.emit("_PyOpcode_macro_expansion[256] = {\n") for inst_name, expansions in expansions_table.items(): uops = [f"{{ {name}, {size}, {offset} }}" for (name, size, offset) in expansions] - out.emit(f"[{inst_name}] = {{ .nuops = {len(expansions)}, .uops = {{ {", ".join(uops)} }} }},\n") + out.emit(f'[{inst_name}] = {{ .nuops = {len(expansions)}, .uops = {{ {", ".join(uops)} }} }},\n') out.emit("};\n") out.emit("#endif // NEED_OPCODE_METADATA\n\n") diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index d68be185f04634..d5d2392e3ed76c 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -188,4 +188,4 @@ def get_stack_effect(inst: Instruction) -> Stack: stack.pop(var) for i, var in enumerate(uop.stack.outputs): stack.push(var) - return stack \ No newline at end of file + return stack From 8b5ae91439076597caa63f06df56600273022c3e Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 20:58:02 +0000 Subject: [PATCH 37/51] Auto-format files --- Tools/cases_generator/analyzer.py | 17 +-- Tools/cases_generator/cwriter.py | 8 +- Tools/cases_generator/generators_common.py | 2 + Tools/cases_generator/opcode_id_generator.py | 6 +- .../opcode_metadata_generator.py | 124 ++++++++++-------- .../cases_generator/py_metadata_generator.py | 16 +-- Tools/cases_generator/stack.py | 3 +- Tools/cases_generator/tier1_generator.py | 1 + Tools/cases_generator/tier2_generator.py | 2 +- Tools/cases_generator/uop_id_generator.py | 1 + .../cases_generator/uop_metadata_generator.py | 11 +- 11 files changed, 102 insertions(+), 89 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index d7b22f30ed8afe..6ec8d341ab652d 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -80,6 +80,7 @@ def name(self) -> str: def properties(self) -> Properties: return SKIP_PROPERTIES + @dataclass class StackItem: name: str @@ -202,7 +203,6 @@ def is_super(self) -> bool: return False - @dataclass class PseudoInstruction: name: str @@ -217,6 +217,7 @@ def dump(self, indent: str) -> None: def properties(self) -> Properties: return Properties.from_list([i.properties for i in self.targets]) + @dataclass class Family: name: str @@ -277,8 +278,8 @@ def analyze_caches(inputs: list[parser.InputEffect]) -> list[CacheEntry]: for cache in caches: if cache.name == "unused": raise analysis_error( - "Unused cache entry in op. Move to enclosing macro.", - cache.tokens[0]) + "Unused cache entry in op. Move to enclosing macro.", cache.tokens[0] + ) return [CacheEntry(i.name, int(i.size)) for i in caches] @@ -360,7 +361,8 @@ def compute_properties(op: parser.InstDef) -> Properties: tier_one_only=variable_used(op, "TIER_ONE_ONLY"), uses_co_consts=variable_used(op, "FRAME_CO_CONSTS"), uses_co_names=variable_used(op, "FRAME_CO_NAMES"), - uses_locals= (variable_used(op, "GETLOCAL") or variable_used(op, "SETLOCAL")) and not has_free, + uses_locals=(variable_used(op, "GETLOCAL") or variable_used(op, "SETLOCAL")) + and not has_free, has_free=has_free, ) @@ -467,6 +469,7 @@ def add_pseudo( pseudo.flags, ) + def assign_opcodes( instructions: dict[str, Instruction], families: dict[str, Family], @@ -489,10 +492,7 @@ def assign_opcodes( instmap["INSTRUMENTED_LINE"] = 254 - - instrumented = [ - name for name in instructions if name.startswith("INSTRUMENTED") - ] + instrumented = [name for name in instructions if name.startswith("INSTRUMENTED")] # Special case: this instruction is implemented in ceval.c # rather than bytecodes.c, so we need to add it explicitly @@ -557,6 +557,7 @@ def add_instruction(name: str) -> None: assert 255 not in instmap.values() return instmap + def analyze_forest(forest: list[parser.AstNode]) -> Analysis: instructions: dict[str, Instruction] = {} uops: dict[str, Uop] = {} diff --git a/Tools/cases_generator/cwriter.py b/Tools/cases_generator/cwriter.py index b0d1b190c1ca19..069f0177a74018 100644 --- a/Tools/cases_generator/cwriter.py +++ b/Tools/cases_generator/cwriter.py @@ -120,8 +120,9 @@ def start_line(self) -> None: self.last_token = None @contextlib.contextmanager - def header_guard(self, name:str) -> Iterator[None]: - self.out.write(f""" + def header_guard(self, name: str) -> Iterator[None]: + self.out.write( + f""" #ifndef {name} #define {name} #ifdef __cplusplus @@ -131,7 +132,8 @@ def header_guard(self, name:str) -> Iterator[None]: """ ) yield - self.out.write(f""" + self.out.write( + f""" #ifdef __cplusplus }} #endif diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index fcac8d1a57760a..c4bee5e6142d67 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -29,6 +29,7 @@ def root_relative_path(filename: str) -> str: # Not relative to root, just return original path. return filename + def write_header(generator: str, sources: list[str], outfile: TextIO) -> None: outfile.write( f"""// This file is generated by {root_relative_path(generator)} @@ -217,6 +218,7 @@ def cflags(p: Properties) -> str: else: return "0" + def get_have_arg_and_min_instrumented(analysis: Analysis) -> tuple[int, int]: min_instrumented = 256 first_arg = 256 diff --git a/Tools/cases_generator/opcode_id_generator.py b/Tools/cases_generator/opcode_id_generator.py index 088499359de754..67a1b165f09a8a 100644 --- a/Tools/cases_generator/opcode_id_generator.py +++ b/Tools/cases_generator/opcode_id_generator.py @@ -25,8 +25,9 @@ DEFAULT_OUTPUT = ROOT / "Include/opcode_ids.h" - -def generate_opcode_header(filenames: list[str], analysis: Analysis, outfile: TextIO) -> None: +def generate_opcode_header( + filenames: list[str], analysis: Analysis, outfile: TextIO +) -> None: write_header(__file__, filenames, outfile) out = CWriter(outfile, 0, False) with out.header_guard("Py_OPCODE_IDS_H"): @@ -44,7 +45,6 @@ def write_define(name: str, op: int) -> None: write_define("MIN_INSTRUMENTED_OPCODE", min_instrumented) - arg_parser = argparse.ArgumentParser( description="Generate the header file with all opcode IDs.", formatter_class=argparse.ArgumentDefaultsHelpFormatter, diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index a97b84f50c662c..10685854d2d47b 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -36,7 +36,7 @@ "OPARG_BOTTOM": 6, "OPARG_SAVE_RETURN_OFFSET": 7, # Skip 8 as the other powers of 2 are sizes - "OPARG_REPLACED": 9 + "OPARG_REPLACED": 9, } @@ -55,11 +55,14 @@ "ESCAPES", ] + def generate_flag_macros(out: CWriter) -> None: for i, flag in enumerate(FLAGS): out.emit(f"#define HAS_{flag}_FLAG ({1< None: - +def generate_stack_effect_functions(analysis: Analysis, out: CWriter) -> None: popped_data: list[tuple[str, str]] = [] pushed_data: list[tuple[str, str]] = [] for inst in analysis.instructions.values(): @@ -102,9 +102,7 @@ def generate_stack_effect_functions( emit_stack_effect_function(out, "pushed", sorted(pushed_data)) -def generate_is_pseudo( - analysis: Analysis, out: CWriter -) -> None: +def generate_is_pseudo(analysis: Analysis, out: CWriter) -> None: """Write the IS_PSEUDO_INSTR macro""" out.emit("\n\n#define IS_PSEUDO_INSTR(OP) ( \\\n") for op in analysis.pseudos: @@ -120,13 +118,11 @@ def get_format(inst: Instruction) -> str: format = "INSTR_FMT_IX" if inst.size > 1: format += "C" - format += "0" * (inst.size-2) + format += "0" * (inst.size - 2) return format -def generate_instruction_formats( - analysis: Analysis, out: CWriter -) -> None: +def generate_instruction_formats(analysis: Analysis, out: CWriter) -> None: # Compute the set of all instruction formats. formats: set[str] = set() for inst in analysis.instructions.values(): @@ -139,9 +135,7 @@ def generate_instruction_formats( out.emit("};\n\n") -def generate_deopt_table( - analysis: Analysis, out: CWriter -) -> None: +def generate_deopt_table(analysis: Analysis, out: CWriter) -> None: out.emit("extern const uint8_t _PyOpcode_Deopt[256];\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const uint8_t _PyOpcode_Deopt[256] = {\n") @@ -158,9 +152,7 @@ def generate_deopt_table( out.emit("#endif // NEED_OPCODE_METADATA\n\n") -def generate_cache_table( - analysis: Analysis, out: CWriter -) -> None: +def generate_cache_table(analysis: Analysis, out: CWriter) -> None: out.emit("extern const uint8_t _PyOpcode_Caches[256];\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const uint8_t _PyOpcode_Caches[256] = {\n") @@ -170,14 +162,12 @@ def generate_cache_table( if inst.name.startswith("INSTRUMENTED"): continue if inst.size > 1: - out.emit(f"[{inst.name}] = {inst.size-1},\n") + out.emit(f"[{inst.name}] = {inst.size-1},\n") out.emit("};\n") out.emit("#endif\n\n") -def generate_name_table( - analysis: Analysis, out: CWriter -) -> None: +def generate_name_table(analysis: Analysis, out: CWriter) -> None: table_size = 256 + len(analysis.pseudos) out.emit(f"extern const char *_PyOpcode_OpName[{table_size}];\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") @@ -190,21 +180,25 @@ def generate_name_table( out.emit("#endif\n\n") -def generate_metadata_table( - analysis: Analysis, out: CWriter -) -> None: +def generate_metadata_table(analysis: Analysis, out: CWriter) -> None: table_size = 256 + len(analysis.pseudos) out.emit("struct opcode_metadata {\n") - out.emit("uint8_t valid_entry;\n"); - out.emit("int8_t instr_format;\n"); - out.emit("int16_t flags;\n"); + out.emit("uint8_t valid_entry;\n") + out.emit("int8_t instr_format;\n") + out.emit("int16_t flags;\n") out.emit("};\n\n") - out.emit(f"extern const struct opcode_metadata _PyOpcode_opcode_metadata[{table_size}];\n") + out.emit( + f"extern const struct opcode_metadata _PyOpcode_opcode_metadata[{table_size}];\n" + ) out.emit("#ifdef NEED_OPCODE_METADATA\n") - out.emit(f"const struct opcode_metadata _PyOpcode_opcode_metadata[{table_size}] = {{\n") - for inst in sorted(analysis.instructions.values(), key = lambda t:t.name): - out.emit(f"[{inst.name}] = {{ true, {get_format(inst)}, {cflags(inst.properties)} }},\n") - for pseudo in sorted(analysis.pseudos.values(), key = lambda t:t.name): + out.emit( + f"const struct opcode_metadata _PyOpcode_opcode_metadata[{table_size}] = {{\n" + ) + for inst in sorted(analysis.instructions.values(), key=lambda t: t.name): + out.emit( + f"[{inst.name}] = {{ true, {get_format(inst)}, {cflags(inst.properties)} }},\n" + ) + for pseudo in sorted(analysis.pseudos.values(), key=lambda t: t.name): flags = cflags(pseudo.properties) for flag in pseudo.flags: if flags == "0": @@ -215,11 +209,10 @@ def generate_metadata_table( out.emit("};\n") out.emit("#endif\n\n") -def generate_expansion_table( - analysis: Analysis, out: CWriter -) -> None: + +def generate_expansion_table(analysis: Analysis, out: CWriter) -> None: expansions_table: dict[str, list[tuple[str, int, int]]] = {} - for inst in sorted(analysis.instructions.values(), key=lambda t:t.name): + for inst in sorted(analysis.instructions.values(), key=lambda t: t.name): offset: int = 0 # Cache effect offset expansions: list[tuple[str, int, int]] = [] # [(name, size, offset), ...] if inst.is_super(): @@ -231,8 +224,12 @@ def generate_expansion_table( assert name2 in analysis.instructions, f"{name2} doesn't match any instr" instr1 = analysis.instructions[name1] instr2 = analysis.instructions[name2] - assert len(instr1.parts) == 1, f"{name1} is not a good superinstruction part" - assert len(instr2.parts) == 1, f"{name2} is not a good superinstruction part" + assert ( + len(instr1.parts) == 1 + ), f"{name1} is not a good superinstruction part" + assert ( + len(instr2.parts) == 1 + ), f"{name2} is not a good superinstruction part" expansions.append((instr1.parts[0].name, OPARG_SIZES["OPARG_TOP"], 0)) expansions.append((instr2.parts[0].name, OPARG_SIZES["OPARG_BOTTOM"], 0)) elif not is_viable_expansion(inst): @@ -251,22 +248,31 @@ def generate_expansion_table( expansions.append((part.name, size, offset if size else 0)) offset += part.size expansions_table[inst.name] = expansions - max_uops = max (len(ex) for ex in expansions_table.values()) + max_uops = max(len(ex) for ex in expansions_table.values()) out.emit(f"#define MAX_UOP_PER_EXPANSION {max_uops}\n") out.emit("struct opcode_macro_expansion {\n") out.emit("int nuops;\n") - out.emit("struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION];\n") + out.emit( + "struct { int16_t uop; int8_t size; int8_t offset; } uops[MAX_UOP_PER_EXPANSION];\n" + ) out.emit("};\n") - out.emit("extern const struct opcode_macro_expansion _PyOpcode_macro_expansion[256];\n\n") + out.emit( + "extern const struct opcode_macro_expansion _PyOpcode_macro_expansion[256];\n\n" + ) out.emit("#ifdef NEED_OPCODE_METADATA\n") out.emit("const struct opcode_macro_expansion\n") out.emit("_PyOpcode_macro_expansion[256] = {\n") for inst_name, expansions in expansions_table.items(): - uops = [f"{{ {name}, {size}, {offset} }}" for (name, size, offset) in expansions] - out.emit(f'[{inst_name}] = {{ .nuops = {len(expansions)}, .uops = {{ {", ".join(uops)} }} }},\n') + uops = [ + f"{{ {name}, {size}, {offset} }}" for (name, size, offset) in expansions + ] + out.emit( + f'[{inst_name}] = {{ .nuops = {len(expansions)}, .uops = {{ {", ".join(uops)} }} }},\n' + ) out.emit("};\n") out.emit("#endif // NEED_OPCODE_METADATA\n\n") + def is_viable_expansion(inst: Instruction) -> bool: "An instruction can be expanded if all its parts are viable for tier 2" for part in inst.parts: @@ -281,9 +287,7 @@ def is_viable_expansion(inst: Instruction) -> bool: return True -def generate_extra_cases( - analysis: Analysis, out: CWriter -) -> None: +def generate_extra_cases(analysis: Analysis, out: CWriter) -> None: out.emit("#define EXTRA_CASES \\\n") valid_opcodes = set(analysis.opmap.values()) for op in range(256): @@ -292,22 +296,24 @@ def generate_extra_cases( out.emit(" ;\n") -def generate_psuedo_targets( - analysis: Analysis, out: CWriter -) -> None: +def generate_psuedo_targets(analysis: Analysis, out: CWriter) -> None: table_size = len(analysis.pseudos) max_targets = max(len(pseudo.targets) for pseudo in analysis.pseudos.values()) out.emit("struct pseudo_targets {\n") out.emit(f"uint8_t targets[{max_targets + 1}];\n") out.emit("};\n") - out.emit(f"extern const struct pseudo_targets _PyOpcode_PseudoTargets[{table_size}];\n") + out.emit( + f"extern const struct pseudo_targets _PyOpcode_PseudoTargets[{table_size}];\n" + ) out.emit("#ifdef NEED_OPCODE_METADATA\n") - out.emit(f"const struct pseudo_targets _PyOpcode_PseudoTargets[{table_size}] = {{\n") + out.emit( + f"const struct pseudo_targets _PyOpcode_PseudoTargets[{table_size}] = {{\n" + ) for pseudo in analysis.pseudos.values(): - targets = [ "0" ] * (max_targets + 1) + targets = ["0"] * (max_targets + 1) for i, target in enumerate(pseudo.targets): targets[i] = target.name - out.emit(f"[{pseudo.name}-256] = {{ {{ {", ".join(targets)} }} }},\n") + out.emit(f"[{pseudo.name}-256] = {{ {{ {', '.join(targets)} }} }},\n") out.emit("};\n\n") out.emit("#endif // NEED_OPCODE_METADATA\n") out.emit("static inline bool\n") @@ -315,8 +321,12 @@ def generate_psuedo_targets( out.emit(f"if (pseudo < 256 || pseudo >= {256+table_size}) {{\n") out.emit(f"return false;\n") out.emit("}\n") - out.emit(f"for (int i = 0; _PyOpcode_PseudoTargets[pseudo-256].targets[i]; i++) {{\n") - out.emit(f"if (_PyOpcode_PseudoTargets[pseudo-256].targets[i] == target) return true;\n") + out.emit( + f"for (int i = 0; _PyOpcode_PseudoTargets[pseudo-256].targets[i]; i++) {{\n" + ) + out.emit( + f"if (_PyOpcode_PseudoTargets[pseudo-256].targets[i] == target) return true;\n" + ) out.emit("}\n") out.emit(f"return false;\n") out.emit("}\n\n") diff --git a/Tools/cases_generator/py_metadata_generator.py b/Tools/cases_generator/py_metadata_generator.py index f89f01d622c948..c0bd9518022c08 100644 --- a/Tools/cases_generator/py_metadata_generator.py +++ b/Tools/cases_generator/py_metadata_generator.py @@ -22,6 +22,7 @@ from cwriter import CWriter from typing import TextIO + def write_header(generator: str, sources: list[str], outfile: TextIO) -> None: outfile.write( f"""# This file is generated by {root_relative_path(generator)} @@ -34,6 +35,7 @@ def write_header(generator: str, sources: list[str], outfile: TextIO) -> None: DEFAULT_OUTPUT = ROOT / "Lib/_opcode_metadata.py" + def get_specialized(analysis: Analysis) -> set[str]: specialized: set[str] = set() for family in analysis.families.values(): @@ -42,9 +44,7 @@ def get_specialized(analysis: Analysis) -> set[str]: return specialized -def generate_specializations( - analysis: Analysis, out: CWriter -) -> None: +def generate_specializations(analysis: Analysis, out: CWriter) -> None: out.emit("_specializations = {\n") for family in analysis.families.values(): out.emit(f'"{family.name}": [\n') @@ -54,9 +54,7 @@ def generate_specializations( out.emit("}\n\n") -def generate_specialized_opmap( - analysis: Analysis, out: CWriter -) -> None: +def generate_specialized_opmap(analysis: Analysis, out: CWriter) -> None: out.emit("_specialized_opmap = {\n") names = [] for family in analysis.families.values(): @@ -69,9 +67,7 @@ def generate_specialized_opmap( out.emit("}\n\n") -def generate_opmap( - analysis: Analysis, out: CWriter -) -> None: +def generate_opmap(analysis: Analysis, out: CWriter) -> None: specialized = get_specialized(analysis) out.emit("opmap = {\n") for inst, op in analysis.opmap.items(): @@ -80,8 +76,6 @@ def generate_opmap( out.emit("}\n\n") - - def generate_py_metadata( filenames: list[str], analysis: Analysis, outfile: TextIO ) -> None: diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index d5d2392e3ed76c..8ad382cdba6dc5 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -29,7 +29,7 @@ def pop(self, item: StackItem) -> None: def push(self, item: StackItem) -> None: self.pushed.append(var_size(item)) - def __sub__(self, other:"StackOffset") -> "StackOffset": + def __sub__(self, other: "StackOffset") -> "StackOffset": res = StackOffset() res.popped = self.popped + other.pushed res.pushed = self.pushed + other.popped @@ -179,6 +179,7 @@ def flush(self, out: CWriter) -> None: def as_comment(self) -> str: return f"/* Variables: {[v.name for v in self.variables]}. Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" + def get_stack_effect(inst: Instruction) -> Stack: stack = Stack() for uop in inst.parts: diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index 49cede978d821a..aba36ec74e5766 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -190,6 +190,7 @@ def generate_tier1_from_files( with open(outfilename, "w") as outfile: generate_tier1(filenames, data, outfile, lines) + if __name__ == "__main__": args = arg_parser.parse_args() if len(args.input) == 0: diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 39732d11f6828c..7897b89b2752a7 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -116,7 +116,7 @@ def write_uop(uop: Uop, out: CWriter, stack: Stack) -> None: for cache in uop.caches: if cache.name != "unused": if cache.size == 4: - type = cast ="PyObject *" + type = cast = "PyObject *" else: type = f"uint{cache.size*16}_t " cast = f"uint{cache.size*16}_t" diff --git a/Tools/cases_generator/uop_id_generator.py b/Tools/cases_generator/uop_id_generator.py index 97205dbb7a0629..633249f1c6b1fe 100644 --- a/Tools/cases_generator/uop_id_generator.py +++ b/Tools/cases_generator/uop_id_generator.py @@ -23,6 +23,7 @@ DEFAULT_OUTPUT = ROOT / "Include/internal/pycore_uop_ids.h" + def generate_uop_ids( filenames: list[str], analysis: Analysis, outfile: TextIO, distinct_namespace: bool ) -> None: diff --git a/Tools/cases_generator/uop_metadata_generator.py b/Tools/cases_generator/uop_metadata_generator.py index 537a9458fc5bff..019a38eb06764e 100644 --- a/Tools/cases_generator/uop_metadata_generator.py +++ b/Tools/cases_generator/uop_metadata_generator.py @@ -25,9 +25,8 @@ DEFAULT_OUTPUT = ROOT / "Include/internal/pycore_uop_metadata.h" -def generate_names_and_flags( - analysis: Analysis, out: CWriter -) -> None: + +def generate_names_and_flags(analysis: Analysis, out: CWriter) -> None: out.emit("extern const uint16_t _PyUop_Flags[MAX_UOP_ID+1];\n") out.emit("extern const char * const _PyOpcode_uop_name[MAX_UOP_ID+1];\n\n") out.emit("#ifdef NEED_OPCODE_METADATA\n") @@ -38,22 +37,24 @@ def generate_names_and_flags( out.emit("};\n\n") out.emit("const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = {\n") - for uop in sorted(analysis.uops.values(), key=lambda t:t.name): + for uop in sorted(analysis.uops.values(), key=lambda t: t.name): if uop.is_viable() and not uop.properties.tier_one_only: out.emit(f'[{uop.name}] = "{uop.name}",\n') out.emit("};\n") out.emit("#endif // NEED_OPCODE_METADATA\n\n") + def generate_uop_metadata( filenames: list[str], analysis: Analysis, outfile: TextIO ) -> None: write_header(__file__, filenames, outfile) out = CWriter(outfile, 0, False) with out.header_guard("Py_CORE_UOP_METADATA_H"): - out.emit('#include \n') + out.emit("#include \n") out.emit('#include "pycore_uop_ids.h"\n') generate_names_and_flags(analysis, out) + arg_parser = argparse.ArgumentParser( description="Generate the header file with uop metadata.", formatter_class=argparse.ArgumentDefaultsHelpFormatter, From 3baa0bb8c0f5fe17e49cc070b6a7fa35f059fddd Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 21:06:17 +0000 Subject: [PATCH 38/51] Move calculation of HAVE_ARG and MIN_INSTRUMENTED to analyzer --- Tools/cases_generator/analyzer.py | 29 ++++++++++++++++++- Tools/cases_generator/generators_common.py | 16 ---------- Tools/cases_generator/opcode_id_generator.py | 6 ++-- .../cases_generator/py_metadata_generator.py | 6 ++-- 4 files changed, 32 insertions(+), 25 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 6ec8d341ab652d..ad5441d244636a 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -235,6 +235,8 @@ class Analysis: families: dict[str, Family] pseudos: dict[str, PseudoInstruction] opmap: dict[str, int] + have_arg: int + min_instrumented: int def analysis_error(message: str, tkn: lexer.Token) -> SyntaxError: @@ -558,6 +560,26 @@ def add_instruction(name: str) -> None: return instmap +def get_have_arg_and_min_instrumented( + instructions: dict[str, Instruction], + pseudos: dict[str, PseudoInstruction], + opmap: dict[str, int], +) -> tuple[int, int]: + min_instrumented = 256 + first_arg = 256 + for name, op in opmap.items(): + if name.startswith("INSTRUMENTED") and op < min_instrumented: + min_instrumented = op + if name == "INSTRUMENTED_LINE": + # INSTRUMENTED_LINE is not defined + continue + if name in pseudos: + continue + if instructions[name].properties.oparg and op < first_arg: + first_arg = op + return first_arg, min_instrumented + + def analyze_forest(forest: list[parser.AstNode]) -> Analysis: instructions: dict[str, Instruction] = {} uops: dict[str, Uop] = {} @@ -607,7 +629,12 @@ def analyze_forest(forest: list[parser.AstNode]) -> Analysis: inst.family = families["BINARY_OP"] families["BINARY_OP"].members.append(inst) opmap = assign_opcodes(instructions, families, pseudos) - return Analysis(instructions, uops, families, pseudos, opmap) + first_arg, min_instrumented = get_have_arg_and_min_instrumented( + instructions, pseudos, opmap + ) + return Analysis( + instructions, uops, families, pseudos, opmap, first_arg, min_instrumented + ) def analyze_files(filenames: list[str]) -> Analysis: diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index c4bee5e6142d67..3d27be62ddf96d 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -217,19 +217,3 @@ def cflags(p: Properties) -> str: return " | ".join(flags) else: return "0" - - -def get_have_arg_and_min_instrumented(analysis: Analysis) -> tuple[int, int]: - min_instrumented = 256 - first_arg = 256 - for name, op in analysis.opmap.items(): - if name.startswith("INSTRUMENTED") and op < min_instrumented: - min_instrumented = op - if name == "INSTRUMENTED_LINE": - # INSTRUMENTED_LINE is not defined - continue - if name in analysis.pseudos: - continue - if analysis.instructions[name].properties.oparg and op < first_arg: - first_arg = op - return first_arg, min_instrumented diff --git a/Tools/cases_generator/opcode_id_generator.py b/Tools/cases_generator/opcode_id_generator.py index 67a1b165f09a8a..dbea3d0b622c87 100644 --- a/Tools/cases_generator/opcode_id_generator.py +++ b/Tools/cases_generator/opcode_id_generator.py @@ -16,7 +16,6 @@ DEFAULT_INPUT, ROOT, write_header, - get_have_arg_and_min_instrumented, ) from cwriter import CWriter from typing import TextIO @@ -40,9 +39,8 @@ def write_define(name: str, op: int) -> None: write_define(name, op) out.emit("\n") - have_arg, min_instrumented = get_have_arg_and_min_instrumented(analysis) - write_define("HAVE_ARGUMENT", have_arg) - write_define("MIN_INSTRUMENTED_OPCODE", min_instrumented) + write_define("HAVE_ARGUMENT", analysis.have_arg) + write_define("MIN_INSTRUMENTED_OPCODE", analysis.min_instrumented) arg_parser = argparse.ArgumentParser( diff --git a/Tools/cases_generator/py_metadata_generator.py b/Tools/cases_generator/py_metadata_generator.py index c0bd9518022c08..b5277a35a3e61d 100644 --- a/Tools/cases_generator/py_metadata_generator.py +++ b/Tools/cases_generator/py_metadata_generator.py @@ -17,7 +17,6 @@ DEFAULT_INPUT, ROOT, root_relative_path, - get_have_arg_and_min_instrumented, ) from cwriter import CWriter from typing import TextIO @@ -84,9 +83,8 @@ def generate_py_metadata( generate_specializations(analysis, out) generate_specialized_opmap(analysis, out) generate_opmap(analysis, out) - have_arg, min_instrumented = get_have_arg_and_min_instrumented(analysis) - out.emit(f"HAVE_ARGUMENT = {have_arg}\n") - out.emit(f"MIN_INSTRUMENTED_OPCODE = {min_instrumented}\n") + out.emit(f"HAVE_ARGUMENT = {analysis.have_arg}\n") + out.emit(f"MIN_INSTRUMENTED_OPCODE = {analysis.min_instrumented}\n") arg_parser = argparse.ArgumentParser( From 4c15c0198fff3bf6431a88598a683a336ad4d439 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 14 Dec 2023 21:25:58 +0000 Subject: [PATCH 39/51] Fix test --- Tools/cases_generator/analyzer.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index ad5441d244636a..1e09149175715e 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -562,7 +562,6 @@ def add_instruction(name: str) -> None: def get_have_arg_and_min_instrumented( instructions: dict[str, Instruction], - pseudos: dict[str, PseudoInstruction], opmap: dict[str, int], ) -> tuple[int, int]: min_instrumented = 256 @@ -573,7 +572,7 @@ def get_have_arg_and_min_instrumented( if name == "INSTRUMENTED_LINE": # INSTRUMENTED_LINE is not defined continue - if name in pseudos: + if name not in instructions: continue if instructions[name].properties.oparg and op < first_arg: first_arg = op @@ -630,7 +629,7 @@ def analyze_forest(forest: list[parser.AstNode]) -> Analysis: families["BINARY_OP"].members.append(inst) opmap = assign_opcodes(instructions, families, pseudos) first_arg, min_instrumented = get_have_arg_and_min_instrumented( - instructions, pseudos, opmap + instructions, opmap ) return Analysis( instructions, uops, families, pseudos, opmap, first_arg, min_instrumented From 54ce18b4b2da408323890937e41d7ddb06f0f1ce Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:03:58 +0000 Subject: [PATCH 40/51] Fix stats --- Python/specialize.c | 1 + 1 file changed, 1 insertion(+) diff --git a/Python/specialize.c b/Python/specialize.c index 7c2a4a42b1dcc3..369b962a545f4e 100644 --- a/Python/specialize.c +++ b/Python/specialize.c @@ -10,6 +10,7 @@ #include "pycore_moduleobject.h" #include "pycore_object.h" #include "pycore_opcode_metadata.h" // _PyOpcode_Caches +#include "pycore_uop_metadata.h" // _PyOpcode_uop_name #include "pycore_opcode_utils.h" // RESUME_AT_FUNC_START #include "pycore_pylifecycle.h" // _PyOS_URandomNonblock() #include "pycore_runtime.h" // _Py_ID() From 8bcf26e7dee614e73404c10fe64eb37d3c939aac Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:09:57 +0000 Subject: [PATCH 41/51] Merge code to create opmap and calculate HAVE_ARG and MIN_INSTRUMENTED --- Include/opcode_ids.h | 2 +- Lib/_opcode_metadata.py | 2 +- Tools/cases_generator/analyzer.py | 31 ++++++------------------------- 3 files changed, 8 insertions(+), 27 deletions(-) diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index e2e27ca00fd47b..fe969342ee79e7 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -231,7 +231,7 @@ extern "C" { #define SETUP_WITH 266 #define STORE_FAST_MAYBE_NULL 267 -#define HAVE_ARGUMENT 45 +#define HAVE_ARGUMENT 44 #define MIN_INSTRUMENTED_OPCODE 236 #ifdef __cplusplus diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index a5119053d557df..fdb099bd0c2ecf 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -329,5 +329,5 @@ 'STORE_FAST_MAYBE_NULL': 267, } -HAVE_ARGUMENT = 45 +HAVE_ARGUMENT = 44 MIN_INSTRUMENTED_OPCODE = 236 diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 1e09149175715e..047d013344ab90 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -476,7 +476,9 @@ def assign_opcodes( instructions: dict[str, Instruction], families: dict[str, Family], pseudos: dict[str, PseudoInstruction], -) -> dict[str, int]: +) -> tuple[dict[str, int], int, int]: + """Assigns opcodes, then returns the opmap, + have_arg and min_instrumented values""" instmap: dict[str, int] = {} # 0 is reserved for cache entries. This helps debugging. @@ -556,27 +558,7 @@ def add_instruction(name: str) -> None: instmap[name] = op pseudos[name].opcode = op - assert 255 not in instmap.values() - return instmap - - -def get_have_arg_and_min_instrumented( - instructions: dict[str, Instruction], - opmap: dict[str, int], -) -> tuple[int, int]: - min_instrumented = 256 - first_arg = 256 - for name, op in opmap.items(): - if name.startswith("INSTRUMENTED") and op < min_instrumented: - min_instrumented = op - if name == "INSTRUMENTED_LINE": - # INSTRUMENTED_LINE is not defined - continue - if name not in instructions: - continue - if instructions[name].properties.oparg and op < first_arg: - first_arg = op - return first_arg, min_instrumented + return instmap, len(no_arg), min_instrumented def analyze_forest(forest: list[parser.AstNode]) -> Analysis: @@ -627,9 +609,8 @@ def analyze_forest(forest: list[parser.AstNode]) -> Analysis: inst = instructions["BINARY_OP_INPLACE_ADD_UNICODE"] inst.family = families["BINARY_OP"] families["BINARY_OP"].members.append(inst) - opmap = assign_opcodes(instructions, families, pseudos) - first_arg, min_instrumented = get_have_arg_and_min_instrumented( - instructions, opmap + opmap, first_arg, min_instrumented = assign_opcodes( + instructions, families, pseudos ) return Analysis( instructions, uops, families, pseudos, opmap, first_arg, min_instrumented From 897d9b310752c29beee3d9bf8afaa349c3cf50c9 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:16:43 +0000 Subject: [PATCH 42/51] Reformat makefile a bit --- Makefile.pre.in | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/Makefile.pre.in b/Makefile.pre.in index d10230df1965e8..92827ec3479526 100644 --- a/Makefile.pre.in +++ b/Makefile.pre.in @@ -1590,20 +1590,20 @@ regen-cases: -t $(srcdir)/Python/opcode_targets.h.new \ -a $(srcdir)/Python/abstract_interp_cases.c.h.new \ $(srcdir)/Python/bytecodes.c - $(PYTHON_FOR_REGEN) \ - $(srcdir)/Tools/cases_generator/opcode_id_generator.py -o $(srcdir)/Include/opcode_ids.h.new $(srcdir)/Python/bytecodes.c - $(PYTHON_FOR_REGEN) \ - $(srcdir)/Tools/cases_generator/uop_id_generator.py -o $(srcdir)/Include/internal/pycore_uop_ids.h.new $(srcdir)/Python/bytecodes.c - $(PYTHON_FOR_REGEN) \ - $(srcdir)/Tools/cases_generator/py_metadata_generator.py -o $(srcdir)/Lib/_opcode_metadata.py.new $(srcdir)/Python/bytecodes.c - $(PYTHON_FOR_REGEN) \ - $(srcdir)/Tools/cases_generator/tier1_generator.py -o $(srcdir)/Python/generated_cases.c.h.new $(srcdir)/Python/bytecodes.c - $(PYTHON_FOR_REGEN) \ - $(srcdir)/Tools/cases_generator/tier2_generator.py -o $(srcdir)/Python/executor_cases.c.h.new $(srcdir)/Python/bytecodes.c - $(PYTHON_FOR_REGEN) \ - $(srcdir)/Tools/cases_generator/opcode_metadata_generator.py -o $(srcdir)/Include/internal/pycore_opcode_metadata.h.new $(srcdir)/Python/bytecodes.c - $(PYTHON_FOR_REGEN) \ - $(srcdir)/Tools/cases_generator/uop_metadata_generator.py -o $(srcdir)/Include/internal/pycore_uop_metadata.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) $(srcdir)/Tools/cases_generator/opcode_id_generator.py \ + -o $(srcdir)/Include/opcode_ids.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) $(srcdir)/Tools/cases_generator/uop_id_generator.py \ + -o $(srcdir)/Include/internal/pycore_uop_ids.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) $(srcdir)/Tools/cases_generator/py_metadata_generator.py \ + -o $(srcdir)/Lib/_opcode_metadata.py.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) $(srcdir)/Tools/cases_generator/tier1_generator.py \ + -o $(srcdir)/Python/generated_cases.c.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) $(srcdir)/Tools/cases_generator/tier2_generator.py \ + -o $(srcdir)/Python/executor_cases.c.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) $(srcdir)/Tools/cases_generator/opcode_metadata_generator.py \ + -o $(srcdir)/Include/internal/pycore_opcode_metadata.h.new $(srcdir)/Python/bytecodes.c + $(PYTHON_FOR_REGEN) $(srcdir)/Tools/cases_generator/uop_metadata_generator.py -o \ + $(srcdir)/Include/internal/pycore_uop_metadata.h.new $(srcdir)/Python/bytecodes.c $(UPDATE_FILE) $(srcdir)/Python/generated_cases.c.h $(srcdir)/Python/generated_cases.c.h.new $(UPDATE_FILE) $(srcdir)/Include/opcode_ids.h $(srcdir)/Include/opcode_ids.h.new $(UPDATE_FILE) $(srcdir)/Include/internal/pycore_uop_ids.h $(srcdir)/Include/internal/pycore_uop_ids.h.new From 0c131a13be3d9474e79b27651894a8944d65301e Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:18:22 +0000 Subject: [PATCH 43/51] use better names --- Python/bytecodes.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index b131b86a040fd2..82d7a71d4989a4 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1453,9 +1453,9 @@ dummy_func( macro(LOAD_GLOBAL) = _SPECIALIZE_LOAD_GLOBAL + - unused/1 + - unused/1 + - unused/1 + + counter/1 + + globals_version/1 + + builtins_version/1 + _LOAD_GLOBAL; op(_GUARD_GLOBALS_VERSION, (version/1 --)) { From d8d7d26337a36d527d53f02c49c00252eb1f192e Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:20:17 +0000 Subject: [PATCH 44/51] Move #include --- Python/optimizer.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/Python/optimizer.c b/Python/optimizer.c index e53f9c7387e7fe..0ff16191680a4b 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -13,13 +13,12 @@ #include #include -#define MAX_EXECUTORS_SIZE 256 - - #define NEED_OPCODE_METADATA #include "pycore_uop_metadata.h" // Uop tables #undef NEED_OPCODE_METADATA +#define MAX_EXECUTORS_SIZE 256 + static bool has_space_for_executor(PyCodeObject *code, _Py_CODEUNIT *instr) From 8f32aa0403568ac04edcc9396d8d126e783322bc Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:31:10 +0000 Subject: [PATCH 45/51] Better comment --- Tools/cases_generator/analyzer.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 047d013344ab90..89f53381ead699 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -604,7 +604,10 @@ def analyze_forest(forest: list[parser.AstNode]) -> Analysis: continue if target.text in instructions: instructions[target.text].is_target = True - # Hack + # Special case BINARY_OP_INPLACE_ADD_UNICODE + # BINARY_OP_INPLACE_ADD_UNICODE is not a normal family member, + # as it is the wrong size, but we need it to maintain an + # historical optimization. if "BINARY_OP_INPLACE_ADD_UNICODE" in instructions: inst = instructions["BINARY_OP_INPLACE_ADD_UNICODE"] inst.family = families["BINARY_OP"] From e04ce0c87a23bae41633626607861383144a271b Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:34:29 +0000 Subject: [PATCH 46/51] Remove unused imports and fix typo --- Tools/cases_generator/generators_common.py | 4 ---- Tools/cases_generator/opcode_metadata_generator.py | 4 ++-- Tools/cases_generator/py_metadata_generator.py | 4 ---- 3 files changed, 2 insertions(+), 10 deletions(-) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 3d27be62ddf96d..8af987ac1b9b6a 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -2,15 +2,11 @@ from typing import TextIO from analyzer import ( - Analysis, Instruction, Uop, - Part, analyze_files, Properties, Skip, - StackItem, - analysis_error, ) from cwriter import CWriter from typing import Callable, Mapping, TextIO, Iterator diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 10685854d2d47b..9233b1296d004d 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -296,7 +296,7 @@ def generate_extra_cases(analysis: Analysis, out: CWriter) -> None: out.emit(" ;\n") -def generate_psuedo_targets(analysis: Analysis, out: CWriter) -> None: +def generate_pseudo_targets(analysis: Analysis, out: CWriter) -> None: table_size = len(analysis.pseudos) max_targets = max(len(pseudo.targets) for pseudo in analysis.pseudos.values()) out.emit("struct pseudo_targets {\n") @@ -359,7 +359,7 @@ def generate_opcode_metadata( generate_cache_table(analysis, out) generate_deopt_table(analysis, out) generate_extra_cases(analysis, out) - generate_psuedo_targets(analysis, out) + generate_pseudo_targets(analysis, out) arg_parser = argparse.ArgumentParser( diff --git a/Tools/cases_generator/py_metadata_generator.py b/Tools/cases_generator/py_metadata_generator.py index b5277a35a3e61d..dc686d8742d1ee 100644 --- a/Tools/cases_generator/py_metadata_generator.py +++ b/Tools/cases_generator/py_metadata_generator.py @@ -4,14 +4,10 @@ """ import argparse -import os.path -import sys from analyzer import ( Analysis, - Instruction, analyze_files, - Uop, ) from generators_common import ( DEFAULT_INPUT, From 7e47f750c5dba988a8098a7084fc9f05c1e4ba61 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:43:58 +0000 Subject: [PATCH 47/51] DRY --- Tools/cases_generator/generators_common.py | 10 +++++----- Tools/cases_generator/opcode_metadata_generator.py | 8 +++++--- Tools/cases_generator/py_metadata_generator.py | 12 ++---------- 3 files changed, 12 insertions(+), 18 deletions(-) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 8af987ac1b9b6a..5a42a05c5c2ef2 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -26,12 +26,12 @@ def root_relative_path(filename: str) -> str: return filename -def write_header(generator: str, sources: list[str], outfile: TextIO) -> None: +def write_header(generator: str, sources: list[str], outfile: TextIO, comment: str = "//") -> None: outfile.write( - f"""// This file is generated by {root_relative_path(generator)} -// from: -// {", ".join(root_relative_path(src) for src in sources)} -// Do not edit! + f"""{comment} This file is generated by {root_relative_path(generator)} +{comment} from: +{comment} {", ".join(root_relative_path(src) for src in sources)} +{comment} Do not edit! """ ) diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 9233b1296d004d..4dee8908c77ec3 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -39,9 +39,6 @@ "OPARG_REPLACED": 9, } - -DEFAULT_OUTPUT = ROOT / "Include/internal/pycore_uop_metadata.h" - FLAGS = [ "ARG", "CONST", @@ -127,6 +124,7 @@ def generate_instruction_formats(analysis: Analysis, out: CWriter) -> None: formats: set[str] = set() for inst in analysis.instructions.values(): formats.add(get_format(inst)) + # Generate an enum for it out.emit("enum InstructionFormat {\n") next_id = 1 for format in sorted(formats): @@ -367,6 +365,10 @@ def generate_opcode_metadata( formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) + +DEFAULT_OUTPUT = ROOT / "Include/internal/pycore_uop_metadata.h" + + arg_parser.add_argument( "-o", "--output", type=str, help="Generated code", default=DEFAULT_OUTPUT ) diff --git a/Tools/cases_generator/py_metadata_generator.py b/Tools/cases_generator/py_metadata_generator.py index dc686d8742d1ee..43811fdacc8a9e 100644 --- a/Tools/cases_generator/py_metadata_generator.py +++ b/Tools/cases_generator/py_metadata_generator.py @@ -13,20 +13,12 @@ DEFAULT_INPUT, ROOT, root_relative_path, + write_header, ) from cwriter import CWriter from typing import TextIO -def write_header(generator: str, sources: list[str], outfile: TextIO) -> None: - outfile.write( - f"""# This file is generated by {root_relative_path(generator)} -# from: -# {", ".join(root_relative_path(src) for src in sources)} -# Do not edit! -""" - ) - DEFAULT_OUTPUT = ROOT / "Lib/_opcode_metadata.py" @@ -74,7 +66,7 @@ def generate_opmap(analysis: Analysis, out: CWriter) -> None: def generate_py_metadata( filenames: list[str], analysis: Analysis, outfile: TextIO ) -> None: - write_header(__file__, filenames, outfile) + write_header(__file__, filenames, outfile, "#") out = CWriter(outfile, 0, False) generate_specializations(analysis, out) generate_specialized_opmap(analysis, out) From 8a36200d6250dd562f7e6cdd896a622eb11d01f6 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:52:33 +0000 Subject: [PATCH 48/51] Convert class to dataclass --- Tools/cases_generator/stack.py | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 8ad382cdba6dc5..94fb82d1139b68 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -15,13 +15,16 @@ def var_size(var: StackItem) -> str: else: return var.size - +@dataclass class StackOffset: "The stack offset of the virtual base of the stack from the physical stack pointer" - def __init__(self) -> None: - self.popped: list[str] = [] - self.pushed: list[str] = [] + popped: list[str] + pushed: list[str] + + @staticmethod + def empty() -> "StackOffset": + return StackOffset([], []) def pop(self, item: StackItem) -> None: self.popped.append(var_size(item)) @@ -30,16 +33,13 @@ def push(self, item: StackItem) -> None: self.pushed.append(var_size(item)) def __sub__(self, other: "StackOffset") -> "StackOffset": - res = StackOffset() - res.popped = self.popped + other.pushed - res.pushed = self.pushed + other.popped - return res + return StackOffset( + self.popped + other.pushed, + self.pushed + other.popped + ) def __neg__(self) -> "StackOffset": - res = StackOffset() - res.popped = self.pushed - res.pushed = self.popped - return res + return StackOffset(self.pushed, self.popped) def simplify(self) -> None: "Remove matching values from both the popped and pushed list" @@ -100,9 +100,9 @@ class SizeMismatch(Exception): class Stack: def __init__(self) -> None: - self.top_offset = StackOffset() - self.base_offset = StackOffset() - self.peek_offset = StackOffset() + self.top_offset = StackOffset.empty() + self.base_offset = StackOffset.empty() + self.peek_offset = StackOffset.empty() self.variables: list[StackItem] = [] self.defined: set[str] = set() From 1b034079c2378fd898314537e522d585d8cf0cbd Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 01:59:54 +0000 Subject: [PATCH 49/51] Remove more unused imports --- Tools/cases_generator/uop_metadata_generator.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/Tools/cases_generator/uop_metadata_generator.py b/Tools/cases_generator/uop_metadata_generator.py index 019a38eb06764e..d4f3a096d2acc1 100644 --- a/Tools/cases_generator/uop_metadata_generator.py +++ b/Tools/cases_generator/uop_metadata_generator.py @@ -4,14 +4,10 @@ """ import argparse -import os.path -import sys from analyzer import ( Analysis, - Instruction, analyze_files, - Uop, ) from generators_common import ( DEFAULT_INPUT, From d0b7a393d7f654215244e9dbf884abffb1d0c624 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 03:08:46 +0000 Subject: [PATCH 50/51] Remove trailing whitespace --- Tools/cases_generator/analyzer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 89f53381ead699..d7aca50d223748 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -477,7 +477,7 @@ def assign_opcodes( families: dict[str, Family], pseudos: dict[str, PseudoInstruction], ) -> tuple[dict[str, int], int, int]: - """Assigns opcodes, then returns the opmap, + """Assigns opcodes, then returns the opmap, have_arg and min_instrumented values""" instmap: dict[str, int] = {} From 227f5f2d4d4869007d389fe135dd8b777caa580f Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 15 Dec 2023 03:26:29 +0000 Subject: [PATCH 51/51] Rename OPARG_SIZES to OPARG_KINDS --- Tools/cases_generator/opcode_metadata_generator.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Tools/cases_generator/opcode_metadata_generator.py b/Tools/cases_generator/opcode_metadata_generator.py index 4dee8908c77ec3..427bb54e5fed59 100644 --- a/Tools/cases_generator/opcode_metadata_generator.py +++ b/Tools/cases_generator/opcode_metadata_generator.py @@ -27,7 +27,7 @@ # Constants used instead of size for macro expansions. # Note: 1, 2, 4 must match actual cache entry sizes. -OPARG_SIZES = { +OPARG_KINDS = { "OPARG_FULL": 0, "OPARG_CACHE_1": 1, "OPARG_CACHE_2": 2, @@ -64,7 +64,7 @@ def generate_flag_macros(out: CWriter) -> None: def generate_oparg_macros(out: CWriter) -> None: - for name, value in OPARG_SIZES.items(): + for name, value in OPARG_KINDS.items(): out.emit(f"#define {name} {value}\n") out.emit("\n") @@ -228,21 +228,21 @@ def generate_expansion_table(analysis: Analysis, out: CWriter) -> None: assert ( len(instr2.parts) == 1 ), f"{name2} is not a good superinstruction part" - expansions.append((instr1.parts[0].name, OPARG_SIZES["OPARG_TOP"], 0)) - expansions.append((instr2.parts[0].name, OPARG_SIZES["OPARG_BOTTOM"], 0)) + expansions.append((instr1.parts[0].name, OPARG_KINDS["OPARG_TOP"], 0)) + expansions.append((instr2.parts[0].name, OPARG_KINDS["OPARG_BOTTOM"], 0)) elif not is_viable_expansion(inst): continue else: for part in inst.parts: size = part.size if part.name == "_SAVE_RETURN_OFFSET": - size = OPARG_SIZES["OPARG_SAVE_RETURN_OFFSET"] + size = OPARG_KINDS["OPARG_SAVE_RETURN_OFFSET"] if isinstance(part, Uop): # Skip specializations if "specializing" in part.annotations: continue if "replaced" in part.annotations: - size = OPARG_SIZES["OPARG_REPLACED"] + size = OPARG_KINDS["OPARG_REPLACED"] expansions.append((part.name, size, offset if size else 0)) offset += part.size expansions_table[inst.name] = expansions