diff --git a/xdis/bytecode.py b/xdis/bytecode.py index cde84872..7fe861e7 100644 --- a/xdis/bytecode.py +++ b/xdis/bytecode.py @@ -363,6 +363,7 @@ def get_logical_instruction_at_offset( elif op in opc.LOCAL_OPS: if opc.version_tuple >= (3, 13) and opname in ( "LOAD_FAST_LOAD_FAST", + "LOAD_FAST_BORROW_LOAD_FAST_BORROW", "STORE_FAST_LOAD_FAST", "STORE_FAST_STORE_FAST", ): diff --git a/xdis/magics.py b/xdis/magics.py index 5f1bdf82..b3516b66 100755 --- a/xdis/magics.py +++ b/xdis/magics.py @@ -611,6 +611,10 @@ def __by_version(magic_versions: Dict[bytes, str]) -> dict: # Fix handling of opcodes that may leave operands on the stack when optimizing LOAD_FAST add_magic_from_int(3625, "3.14b3") +# Fix missing exception handlers in logical expression +add_magic_from_int(3626, "3.14rc2") + +# Fix miscompilation of some module-level annotations add_magic_from_int(3627, "3.14rc3") # add_magic_from_int(3655, "3.15.0a0") diff --git a/xdis/opcodes/opcode_314.py b/xdis/opcodes/opcode_314.py index 297baa7a..b3edd5e9 100644 --- a/xdis/opcodes/opcode_314.py +++ b/xdis/opcodes/opcode_314.py @@ -1,418 +1,292 @@ """ -CPython 3.13 bytecode opcodes +CPython 3.14 bytecode opcodes """ -import xdis.opcodes.opcode_313 as opcode_313 -from xdis.opcodes.base import def_op, finalize_opcodes, init_opdata, rm_op, update_pj3 - +from xdis.opcodes.base import ( + init_opdata, + binary_op, + call_op, + compare_op, + const_op, + def_op, + free_op, + jabs_op, + jrel_op, + local_op, + name_op, + nargs_op, + store_op, + unary_op, + varargs_op, + update_pj3, + finalize_opcodes, +) version_tuple = (3, 14) python_implementation = "CPython" loc = locals() -init_opdata(loc, opcode_313, version_tuple) +init_opdata(loc, None, version_tuple) + +# extend opcodes to cover pseudo ops +loc["opname"].extend([f"<{i}>" for i in range(256, 267)]) +loc["oppop"].extend([0] * 11) +loc["oppush"].extend([0] * 11) -# OP NAME OPCODE -# ------------------------------------------------- -rm_op(loc, 'BEFORE_ASYNC_WITH', 1) -rm_op(loc, 'BEFORE_WITH', 2) -rm_op(loc, 'BINARY_SLICE', 4) -rm_op(loc, 'BINARY_SUBSCR', 5) -rm_op(loc, 'CHECK_EG_MATCH', 6) -rm_op(loc, 'CHECK_EXC_MATCH', 7) -rm_op(loc, 'CLEANUP_THROW', 8) -rm_op(loc, 'DELETE_SUBSCR', 9) -rm_op(loc, 'END_ASYNC_FOR', 10) -rm_op(loc, 'END_FOR', 11) -rm_op(loc, 'END_SEND', 12) -rm_op(loc, 'EXIT_INIT_CHECK', 13) -rm_op(loc, 'FORMAT_SIMPLE', 14) -rm_op(loc, 'FORMAT_WITH_SPEC', 15) -rm_op(loc, 'GET_AITER', 16) -rm_op(loc, 'GET_ANEXT', 18) -rm_op(loc, 'GET_ITER', 19) -rm_op(loc, 'GET_LEN', 20) -rm_op(loc, 'GET_YIELD_FROM_ITER', 21) -rm_op(loc, 'INTERPRETER_EXIT', 22) -rm_op(loc, 'LOAD_ASSERTION_ERROR', 23) -rm_op(loc, 'LOAD_BUILD_CLASS', 24) -rm_op(loc, 'LOAD_LOCALS', 25) -rm_op(loc, 'MAKE_FUNCTION', 26) -rm_op(loc, 'MATCH_KEYS', 27) -rm_op(loc, 'MATCH_MAPPING', 28) -rm_op(loc, 'MATCH_SEQUENCE', 29) -rm_op(loc, 'NOP', 30) -rm_op(loc, 'POP_EXCEPT', 31) -rm_op(loc, 'POP_TOP', 32) -rm_op(loc, 'PUSH_EXC_INFO', 33) -rm_op(loc, 'PUSH_NULL', 34) -rm_op(loc, 'RETURN_GENERATOR', 35) -rm_op(loc, 'RETURN_VALUE', 36) -rm_op(loc, 'SETUP_ANNOTATIONS', 37) -rm_op(loc, 'STORE_SLICE', 38) -rm_op(loc, 'STORE_SUBSCR', 39) -rm_op(loc, 'TO_BOOL', 40) -rm_op(loc, 'UNARY_INVERT', 41) -rm_op(loc, 'UNARY_NEGATIVE', 42) -rm_op(loc, 'UNARY_NOT', 43) -rm_op(loc, 'WITH_EXCEPT_START', 44) -rm_op(loc, 'BINARY_OP', 45) -rm_op(loc, 'BUILD_CONST_KEY_MAP', 46) -rm_op(loc, 'BUILD_LIST', 47) -rm_op(loc, 'BUILD_MAP', 48) -rm_op(loc, 'BUILD_SET', 49) -rm_op(loc, 'BUILD_SLICE', 50) -rm_op(loc, 'BUILD_STRING', 51) -rm_op(loc, 'BUILD_TUPLE', 52) -rm_op(loc, 'CALL', 53) -rm_op(loc, 'CALL_FUNCTION_EX', 54) -rm_op(loc, 'CALL_INTRINSIC_1', 55) -rm_op(loc, 'CALL_INTRINSIC_2', 56) -rm_op(loc, 'CALL_KW', 57) -rm_op(loc, 'COMPARE_OP', 58) -rm_op(loc, 'CONTAINS_OP', 59) -rm_op(loc, 'CONVERT_VALUE', 60) -rm_op(loc, 'COPY', 61) -rm_op(loc, 'COPY_FREE_VARS', 62) -rm_op(loc, 'DELETE_ATTR', 63) -rm_op(loc, 'DELETE_DEREF', 64) -rm_op(loc, 'DELETE_FAST', 65) -rm_op(loc, 'DELETE_GLOBAL', 66) -rm_op(loc, 'DELETE_NAME', 67) -rm_op(loc, 'DICT_MERGE', 68) -rm_op(loc, 'DICT_UPDATE', 69) -rm_op(loc, 'ENTER_EXECUTOR', 70) -rm_op(loc, 'EXTENDED_ARG', 71) -rm_op(loc, 'FOR_ITER', 72) -rm_op(loc, 'GET_AWAITABLE', 73) -rm_op(loc, 'IMPORT_FROM', 74) -rm_op(loc, 'IMPORT_NAME', 75) -rm_op(loc, 'IS_OP', 76) -rm_op(loc, 'JUMP_BACKWARD', 77) -rm_op(loc, 'JUMP_BACKWARD_NO_INTERRUPT', 78) -rm_op(loc, 'JUMP_FORWARD', 79) -rm_op(loc, 'LIST_APPEND', 80) -rm_op(loc, 'LIST_EXTEND', 81) -rm_op(loc, 'LOAD_ATTR', 82) -rm_op(loc, 'LOAD_CONST', 83) -rm_op(loc, 'LOAD_DEREF', 84) -rm_op(loc, 'LOAD_FAST', 85) -rm_op(loc, 'LOAD_FAST_AND_CLEAR', 86) -rm_op(loc, 'LOAD_FAST_CHECK', 87) -rm_op(loc, 'LOAD_FAST_LOAD_FAST', 88) -rm_op(loc, 'LOAD_FROM_DICT_OR_DEREF', 89) -rm_op(loc, 'LOAD_FROM_DICT_OR_GLOBALS', 90) -rm_op(loc, 'LOAD_GLOBAL', 91) -rm_op(loc, 'LOAD_NAME', 92) -rm_op(loc, 'LOAD_SUPER_ATTR', 93) -rm_op(loc, 'MAKE_CELL', 94) -rm_op(loc, 'MAP_ADD', 95) -rm_op(loc, 'MATCH_CLASS', 96) -rm_op(loc, 'POP_JUMP_IF_FALSE', 97) -rm_op(loc, 'POP_JUMP_IF_NONE', 98) -rm_op(loc, 'POP_JUMP_IF_NOT_NONE', 99) -rm_op(loc, 'POP_JUMP_IF_TRUE', 100) -rm_op(loc, 'RAISE_VARARGS', 101) -rm_op(loc, 'RERAISE', 102) -rm_op(loc, 'RETURN_CONST', 103) -rm_op(loc, 'SEND', 104) -rm_op(loc, 'SET_ADD', 105) -rm_op(loc, 'SET_FUNCTION_ATTRIBUTE', 106) -rm_op(loc, 'SET_UPDATE', 107) -rm_op(loc, 'STORE_ATTR', 108) -rm_op(loc, 'STORE_DEREF', 109) -rm_op(loc, 'STORE_FAST', 110) -rm_op(loc, 'STORE_FAST_LOAD_FAST', 111) -rm_op(loc, 'STORE_FAST_STORE_FAST', 112) -rm_op(loc, 'STORE_GLOBAL', 113) -rm_op(loc, 'STORE_NAME', 114) -rm_op(loc, 'SWAP', 115) -rm_op(loc, 'UNPACK_EX', 116) -rm_op(loc, 'UNPACK_SEQUENCE', 117) -rm_op(loc, 'YIELD_VALUE', 118) -rm_op(loc, 'RESUME', 149) -rm_op(loc, 'INSTRUMENTED_RESUME', 236) -rm_op(loc, 'INSTRUMENTED_END_FOR', 237) -rm_op(loc, 'INSTRUMENTED_END_SEND', 238) -rm_op(loc, 'INSTRUMENTED_RETURN_VALUE', 239) -rm_op(loc, 'INSTRUMENTED_RETURN_CONST', 240) -rm_op(loc, 'INSTRUMENTED_YIELD_VALUE', 241) -rm_op(loc, 'INSTRUMENTED_LOAD_SUPER_ATTR', 242) -rm_op(loc, 'INSTRUMENTED_FOR_ITER', 243) -rm_op(loc, 'INSTRUMENTED_CALL', 244) -rm_op(loc, 'INSTRUMENTED_CALL_KW', 245) -rm_op(loc, 'INSTRUMENTED_CALL_FUNCTION_EX', 246) -rm_op(loc, 'INSTRUMENTED_INSTRUCTION', 247) -rm_op(loc, 'INSTRUMENTED_JUMP_FORWARD', 248) -rm_op(loc, 'INSTRUMENTED_JUMP_BACKWARD', 249) -rm_op(loc, 'INSTRUMENTED_POP_JUMP_IF_TRUE', 250) -rm_op(loc, 'INSTRUMENTED_POP_JUMP_IF_FALSE', 251) -rm_op(loc, 'INSTRUMENTED_POP_JUMP_IF_NONE', 252) -rm_op(loc, 'INSTRUMENTED_POP_JUMP_IF_NOT_NONE', 253) -rm_op(loc, 'JUMP', 256) -rm_op(loc, 'JUMP_NO_INTERRUPT', 257) -rm_op(loc, 'LOAD_CLOSURE', 258) -rm_op(loc, 'LOAD_METHOD', 259) -rm_op(loc, 'LOAD_SUPER_METHOD', 260) -rm_op(loc, 'LOAD_ZERO_SUPER_ATTR', 261) -rm_op(loc, 'LOAD_ZERO_SUPER_METHOD', 262) -rm_op(loc, 'POP_BLOCK', 263) -rm_op(loc, 'SETUP_CLEANUP', 264) -rm_op(loc, 'SETUP_FINALLY', 265) -rm_op(loc, 'SETUP_WITH', 266) -rm_op(loc, 'STORE_FAST_MAYBE_NULL', 267) +# OP NAME OPCODE POP PUSH +# --------------------------------------------------------------------------- +def_op(loc, "CACHE", 0, 0, 0) +def_op(loc, "BINARY_SLICE", 1, 3, 1) +def_op(loc, "BUILD_TEMPLATE", 2, 2, 1) +local_op(loc, "BINARY_OP_INPLACE_ADD_UNICODE", 3, 2, 0) +def_op(loc, "CALL_FUNCTION_EX", 4, 4, 1) +def_op(loc, "CHECK_EG_MATCH", 5, 2, 2) +def_op(loc, "CHECK_EXC_MATCH", 6, 2, 2) +def_op(loc, "CLEANUP_THROW", 7, 3, 2) +def_op(loc, "DELETE_SUBSCR", 8, 2, 0) +def_op(loc, "END_FOR", 9, 1, 0) +def_op(loc, "END_SEND", 10, 2, 1) +def_op(loc, "EXIT_INIT_CHECK", 11, 1, 0) +def_op(loc, "FORMAT_SIMPLE", 12, 1, 1) +def_op(loc, "FORMAT_WITH_SPEC", 13, 2, 1) +def_op(loc, "GET_AITER", 14, 1, 1) +def_op(loc, "GET_ANEXT", 15, 1, 2) +def_op(loc, "GET_ITER", 16, 1, 2) +def_op(loc, "RESERVED", 17, 0, 0) +def_op(loc, "GET_LEN", 18, 1, 2) +def_op(loc, "GET_YIELD_FROM_ITER", 19, 1, 1) +def_op(loc, "INTERPRETER_EXIT", 20, 1, 0) +def_op(loc, "LOAD_BUILD_CLASS", 21, 0, 1) +def_op(loc, "LOAD_LOCALS", 22, 0, 1) +def_op(loc, "MAKE_FUNCTION", 23, 1, 1) +def_op(loc, "MATCH_KEYS", 24, 2, 3) +def_op(loc, "MATCH_MAPPING", 25, 1, 2) +def_op(loc, "MATCH_SEQUENCE", 26, 1, 2) +def_op(loc, "NOP", 27, 0, 0) +def_op(loc, "NOT_TAKEN", 28, 0, 0) +def_op(loc, "POP_EXCEPT", 29, 1, 0) +def_op(loc, "POP_ITER", 30, 2, 0) +def_op(loc, "POP_TOP", 31, 1, 0) +def_op(loc, "PUSH_EXC_INFO", 32, 1, 2) +def_op(loc, "PUSH_NULL", 33, 0, 1) +def_op(loc, "RETURN_GENERATOR", 34, 0, 1) +def_op(loc, "RETURN_VALUE", 35, 1, 1) +def_op(loc, "SETUP_ANNOTATIONS", 36, 0, 0) +store_op(loc, "STORE_SLICE", 37, 4, 0) +store_op(loc, "STORE_SUBSCR", 38, 3, 0) +unary_op(loc, "TO_BOOL", 39, 1, 1) +unary_op(loc, "UNARY_INVERT", 40, 1, 1) +unary_op(loc, "UNARY_NEGATIVE", 41, 1, 1) +unary_op(loc, "UNARY_NOT", 42, 1, 1) +def_op(loc, "WITH_EXCEPT_START", 43, 5, 6) +binary_op(loc, "BINARY_OP", 44, 2, 1) +def_op(loc, "BUILD_INTERPOLATION", 45, 2, 1) # pops 2 + (oparg & 1) +varargs_op(loc, "BUILD_LIST", 46, -1, 1) # TOS is count of list items +varargs_op(loc, "BUILD_MAP", 47, 0, 1) # argument is dictionary count to be popped +varargs_op(loc, "BUILD_SET", 48, -1, 1) # TOS is count of set items +varargs_op(loc, "BUILD_SLICE", 49, -1, 1) # TOS is slice +varargs_op(loc, "BUILD_STRING", 50, -1, 1) # TOS is concatenated strings +varargs_op(loc, "BUILD_TUPLE", 51, -1, 1) # TOS is count of tuple items +call_op(loc, "CALL", 52, -2, 1) # pops 2 + oparg; TOS is return value +def_op(loc, "CALL_INTRINSIC_1", 53, 1, 1) +def_op(loc, "CALL_INTRINSIC_2", 54, 2, 1) +call_op(loc, "CALL_KW", 55, -3, 1) # pops 3 + oparg; TOS is return value +compare_op(loc, "COMPARE_OP", 56, 2, 1) +binary_op(loc, "CONTAINS_OP", 57, 2, 1) +def_op(loc, "CONVERT_VALUE", 58, 1, 1) +def_op(loc, "COPY", 59, 0, 1) +def_op(loc, "COPY_FREE_VARS", 60, 0, 0) +name_op(loc, "DELETE_ATTR", 61, 1, 0) +free_op(loc, "DELETE_DEREF", 62, 0, 0) +local_op(loc, "DELETE_FAST", 63, 0, 0) +name_op(loc, "DELETE_GLOBAL", 64, 0, 0) +name_op(loc, "DELETE_NAME", 65, 0, 0) +def_op(loc, "DICT_MERGE", 66, 1, 0) +def_op(loc, "DICT_UPDATE", 67, 1, 0) +jrel_op(loc, "END_ASYNC_FOR", 68, 2, 0, conditional=True) +def_op(loc, "EXTENDED_ARG", 69, 0, 0) +jrel_op(loc, "FOR_ITER", 70, 0, 1, conditional=True) +def_op(loc, "GET_AWAITABLE", 71, 1, 1) +name_op(loc, "IMPORT_FROM", 72, 1, 2) +name_op(loc, "IMPORT_NAME", 73, 2, 1) +compare_op(loc, "IS_OP", 74, 2, 1) +jrel_op(loc, "JUMP_BACKWARD", 75, 0, 0, conditional=False) +jrel_op(loc, "JUMP_BACKWARD_NO_INTERRUPT", 76, 0, 0, conditional=False) +jrel_op(loc, "JUMP_FORWARD", 77, 0, 0, conditional=False) +def_op(loc, "LIST_APPEND", 78, 1, 0) +def_op(loc, "LIST_EXTEND", 79, 1, 0) +name_op(loc, "LOAD_ATTR", 80, 1, 1) # pops 1 + (oparg & 1) +def_op(loc, "LOAD_COMMON_CONSTANT", 81, 0, 1) +const_op(loc, "LOAD_CONST", 82, 0, 1) +local_op(loc, "LOAD_DEREF", 83, 0, 1) +local_op(loc, "LOAD_FAST", 84, 0, 1) +local_op(loc, "LOAD_FAST_AND_CLEAR", 85, 0, 1) +local_op(loc, "LOAD_FAST_BORROW", 86, 0, 1) +local_op(loc, "LOAD_FAST_BORROW_LOAD_FAST_BORROW", 87, 0, 2) +local_op(loc, "LOAD_FAST_CHECK", 88, 0, 1) +local_op(loc, "LOAD_FAST_LOAD_FAST", 89, 0, 2) +free_op(loc, "LOAD_FROM_DICT_OR_DEREF", 90, 1, 1) +name_op(loc, "LOAD_FROM_DICT_OR_GLOBALS", 91, 1, 1) +name_op(loc, "LOAD_GLOBAL", 92, 0, 1) # pops 1 + (oparg & 1) +name_op(loc, "LOAD_NAME", 93, 0, 1) +def_op(loc, "LOAD_SMALL_INT", 94, 0, 1) +def_op(loc, "LOAD_SPECIAL", 95, 1, 2) +name_op(loc, "LOAD_SUPER_ATTR", 96, 3, 1) # pops 1 + (oparg & 1) +free_op(loc, "MAKE_CELL", 97, 0, 0) +def_op(loc, "MAP_ADD", 98, 2, 0) +def_op(loc, "MATCH_CLASS", 99, 3, 1) +jrel_op(loc, "POP_JUMP_IF_FALSE", 100, 1, 0, conditional=True) +jrel_op(loc, "POP_JUMP_IF_NONE", 101, 1, 0, conditional=True) +jrel_op(loc, "POP_JUMP_IF_NOT_NONE", 102, 1, 0, conditional=True) +jrel_op(loc, "POP_JUMP_IF_TRUE", 103, 1, 0, conditional=True) +varargs_op(loc, "RAISE_VARARGS", 104, -1, 0) +def_op(loc, "RERAISE", 105, 1, 0) +jrel_op(loc, "SEND", 106, 2, 2, conditional=True) +def_op(loc, "SET_ADD", 107, 1, 0) +def_op(loc, "SET_FUNCTION_ATTRIBUTE", 108, 2, 1) +def_op(loc, "SET_UPDATE", 109, 1, 0) +store_op(loc, "STORE_ATTR", 110, 2, 0, is_type="name") +store_op(loc, "STORE_DEREF", 111, 1, 0, is_type="free") +store_op(loc, "STORE_FAST", 112, 1, 0, is_type="local") +local_op(loc, "STORE_FAST_LOAD_FAST", 113, 1, 1) +store_op(loc, "STORE_FAST_STORE_FAST", 114, 2, 0, is_type="local") +store_op(loc, "STORE_GLOBAL", 115, 1, 0, is_type="name") +store_op(loc, "STORE_NAME", 116, 1, 0, is_type="name") +def_op(loc, "SWAP", 117, 0, 0) +varargs_op(loc, "UNPACK_EX", 118, 1, -1) # pushes 1 + (oparg & 0xFF) + (oparg >> 8) +varargs_op(loc, "UNPACK_SEQUENCE", 119, 0, -1) # unpacks TOS, arg is the count +def_op(loc, "YIELD_VALUE", 120, 1, 1) +def_op(loc, "RESUME", 128, 0, 0) -# OP NAME OPCODE POP PUSH -# -------------------------------------------------------------------- -def_op(loc, 'BINARY_SLICE', 1) -def_op(loc, 'BUILD_TEMPLATE', 2) -def_op(loc, 'BINARY_OP_INPLACE_ADD_UNICODE', 3) -def_op(loc, 'CALL_FUNCTION_EX', 4) -def_op(loc, 'CHECK_EG_MATCH', 5) -def_op(loc, 'CHECK_EXC_MATCH', 6) -def_op(loc, 'CLEANUP_THROW', 7) -def_op(loc, 'DELETE_SUBSCR', 8) -def_op(loc, 'END_FOR', 9) -def_op(loc, 'END_SEND', 10) -def_op(loc, 'EXIT_INIT_CHECK', 11) -def_op(loc, 'FORMAT_SIMPLE', 12) -def_op(loc, 'FORMAT_WITH_SPEC', 13) -def_op(loc, 'GET_AITER', 14) -def_op(loc, 'GET_ANEXT', 15) -def_op(loc, 'GET_ITER', 16) -def_op(loc, 'GET_LEN', 18) -def_op(loc, 'GET_YIELD_FROM_ITER', 19) -def_op(loc, 'INTERPRETER_EXIT', 20) -def_op(loc, 'LOAD_BUILD_CLASS', 21) -def_op(loc, 'LOAD_LOCALS', 22) -def_op(loc, 'MAKE_FUNCTION', 23) -def_op(loc, 'MATCH_KEYS', 24) -def_op(loc, 'MATCH_MAPPING', 25) -def_op(loc, 'MATCH_SEQUENCE', 26) -def_op(loc, 'NOP', 27) -def_op(loc, 'NOT_TAKEN', 28) -def_op(loc, 'POP_EXCEPT', 29) -def_op(loc, 'POP_ITER', 30) -def_op(loc, 'POP_TOP', 31) -def_op(loc, 'PUSH_EXC_INFO', 32) -def_op(loc, 'PUSH_NULL', 33) -def_op(loc, 'RETURN_GENERATOR', 34) -def_op(loc, 'RETURN_VALUE', 35) -def_op(loc, 'SETUP_ANNOTATIONS', 36) -def_op(loc, 'STORE_SLICE', 37) -def_op(loc, 'STORE_SUBSCR', 38) -def_op(loc, 'TO_BOOL', 39) -def_op(loc, 'UNARY_INVERT', 40) -def_op(loc, 'UNARY_NEGATIVE', 41) -def_op(loc, 'UNARY_NOT', 42) -def_op(loc, 'WITH_EXCEPT_START', 43) -def_op(loc, 'BINARY_OP', 44) -def_op(loc, 'BUILD_INTERPOLATION', 45) -def_op(loc, 'BUILD_LIST', 46) -def_op(loc, 'BUILD_MAP', 47) -def_op(loc, 'BUILD_SET', 48) -def_op(loc, 'BUILD_SLICE', 49) -def_op(loc, 'BUILD_STRING', 50) -def_op(loc, 'BUILD_TUPLE', 51) -def_op(loc, 'CALL', 52) -def_op(loc, 'CALL_INTRINSIC_1', 53) -def_op(loc, 'CALL_INTRINSIC_2', 54) -def_op(loc, 'CALL_KW', 55) -def_op(loc, 'COMPARE_OP', 56) -def_op(loc, 'CONTAINS_OP', 57) -def_op(loc, 'CONVERT_VALUE', 58) -def_op(loc, 'COPY', 59) -def_op(loc, 'COPY_FREE_VARS', 60) -def_op(loc, 'DELETE_ATTR', 61) -def_op(loc, 'DELETE_DEREF', 62) -def_op(loc, 'DELETE_FAST', 63) -def_op(loc, 'DELETE_GLOBAL', 64) -def_op(loc, 'DELETE_NAME', 65) -def_op(loc, 'DICT_MERGE', 66) -def_op(loc, 'DICT_UPDATE', 67) -def_op(loc, 'END_ASYNC_FOR', 68) -def_op(loc, 'EXTENDED_ARG', 69) -def_op(loc, 'FOR_ITER', 70) -def_op(loc, 'GET_AWAITABLE', 71) -def_op(loc, 'IMPORT_FROM', 72) -def_op(loc, 'IMPORT_NAME', 73) -def_op(loc, 'IS_OP', 74) -def_op(loc, 'JUMP_BACKWARD', 75) -def_op(loc, 'JUMP_BACKWARD_NO_INTERRUPT', 76) -def_op(loc, 'JUMP_FORWARD', 77) -def_op(loc, 'LIST_APPEND', 78) -def_op(loc, 'LIST_EXTEND', 79) -def_op(loc, 'LOAD_ATTR', 80) -def_op(loc, 'LOAD_COMMON_CONSTANT', 81) -def_op(loc, 'LOAD_CONST', 82) -def_op(loc, 'LOAD_DEREF', 83) -def_op(loc, 'LOAD_FAST', 84) -def_op(loc, 'LOAD_FAST_AND_CLEAR', 85) -def_op(loc, 'LOAD_FAST_BORROW', 86) -def_op(loc, 'LOAD_FAST_BORROW_LOAD_FAST_BORROW', 87) -def_op(loc, 'LOAD_FAST_CHECK', 88) -def_op(loc, 'LOAD_FAST_LOAD_FAST', 89) -def_op(loc, 'LOAD_FROM_DICT_OR_DEREF', 90) -def_op(loc, 'LOAD_FROM_DICT_OR_GLOBALS', 91) -def_op(loc, 'LOAD_GLOBAL', 92) -def_op(loc, 'LOAD_NAME', 93) -def_op(loc, 'LOAD_SMALL_INT', 94) -def_op(loc, 'LOAD_SPECIAL', 95) -def_op(loc, 'LOAD_SUPER_ATTR', 96) -def_op(loc, 'MAKE_CELL', 97) -def_op(loc, 'MAP_ADD', 98) -def_op(loc, 'MATCH_CLASS', 99) -def_op(loc, 'POP_JUMP_IF_FALSE', 100) -def_op(loc, 'POP_JUMP_IF_NONE', 101) -def_op(loc, 'POP_JUMP_IF_NOT_NONE', 102) -def_op(loc, 'POP_JUMP_IF_TRUE', 103) -def_op(loc, 'RAISE_VARARGS', 104) -def_op(loc, 'RERAISE', 105) -def_op(loc, 'SEND', 106) -def_op(loc, 'SET_ADD', 107) -def_op(loc, 'SET_FUNCTION_ATTRIBUTE', 108) -def_op(loc, 'SET_UPDATE', 109) -def_op(loc, 'STORE_ATTR', 110) -def_op(loc, 'STORE_DEREF', 111) -def_op(loc, 'STORE_FAST', 112) -def_op(loc, 'STORE_FAST_LOAD_FAST', 113) -def_op(loc, 'STORE_FAST_STORE_FAST', 114) -def_op(loc, 'STORE_GLOBAL', 115) -def_op(loc, 'STORE_NAME', 116) -def_op(loc, 'SWAP', 117) -def_op(loc, 'UNPACK_EX', 118) -def_op(loc, 'UNPACK_SEQUENCE', 119) -def_op(loc, 'YIELD_VALUE', 120) -def_op(loc, 'RESUME', 128) -def_op(loc, 'BINARY_OP_ADD_FLOAT', 129) -def_op(loc, 'BINARY_OP_ADD_INT', 130) -def_op(loc, 'BINARY_OP_ADD_UNICODE', 131) -def_op(loc, 'BINARY_OP_EXTEND', 132) -def_op(loc, 'BINARY_OP_MULTIPLY_FLOAT', 133) -def_op(loc, 'BINARY_OP_MULTIPLY_INT', 134) -def_op(loc, 'BINARY_OP_SUBSCR_DICT', 135) -def_op(loc, 'BINARY_OP_SUBSCR_GETITEM', 136) -def_op(loc, 'BINARY_OP_SUBSCR_LIST_INT', 137) -def_op(loc, 'BINARY_OP_SUBSCR_LIST_SLICE', 138) -def_op(loc, 'BINARY_OP_SUBSCR_STR_INT', 139) -def_op(loc, 'BINARY_OP_SUBSCR_TUPLE_INT', 140) -def_op(loc, 'BINARY_OP_SUBTRACT_FLOAT', 141) -def_op(loc, 'BINARY_OP_SUBTRACT_INT', 142) -def_op(loc, 'CALL_ALLOC_AND_ENTER_INIT', 143) -def_op(loc, 'CALL_BOUND_METHOD_EXACT_ARGS', 144) -def_op(loc, 'CALL_BOUND_METHOD_GENERAL', 145) -def_op(loc, 'CALL_BUILTIN_CLASS', 146) -def_op(loc, 'CALL_BUILTIN_FAST', 147) -def_op(loc, 'CALL_BUILTIN_FAST_WITH_KEYWORDS', 148) -def_op(loc, 'CALL_BUILTIN_O', 149) -def_op(loc, 'CALL_ISINSTANCE', 150) -def_op(loc, 'CALL_KW_BOUND_METHOD', 151) -def_op(loc, 'CALL_KW_NON_PY', 152) -def_op(loc, 'CALL_KW_PY', 153) -def_op(loc, 'CALL_LEN', 154) -def_op(loc, 'CALL_LIST_APPEND', 155) -def_op(loc, 'CALL_METHOD_DESCRIPTOR_FAST', 156) -def_op(loc, 'CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS', 157) -def_op(loc, 'CALL_METHOD_DESCRIPTOR_NOARGS', 158) -def_op(loc, 'CALL_METHOD_DESCRIPTOR_O', 159) -def_op(loc, 'CALL_NON_PY_GENERAL', 160) -def_op(loc, 'CALL_PY_EXACT_ARGS', 161) -def_op(loc, 'CALL_PY_GENERAL', 162) -def_op(loc, 'CALL_STR_1', 163) -def_op(loc, 'CALL_TUPLE_1', 164) -def_op(loc, 'CALL_TYPE_1', 165) -def_op(loc, 'COMPARE_OP_FLOAT', 166) -def_op(loc, 'COMPARE_OP_INT', 167) -def_op(loc, 'COMPARE_OP_STR', 168) -def_op(loc, 'CONTAINS_OP_DICT', 169) -def_op(loc, 'CONTAINS_OP_SET', 170) -def_op(loc, 'FOR_ITER_GEN', 171) -def_op(loc, 'FOR_ITER_LIST', 172) -def_op(loc, 'FOR_ITER_RANGE', 173) -def_op(loc, 'FOR_ITER_TUPLE', 174) -def_op(loc, 'JUMP_BACKWARD_JIT', 175) -def_op(loc, 'JUMP_BACKWARD_NO_JIT', 176) -def_op(loc, 'LOAD_ATTR_CLASS', 177) -def_op(loc, 'LOAD_ATTR_CLASS_WITH_METACLASS_CHECK', 178) -def_op(loc, 'LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN', 179) -def_op(loc, 'LOAD_ATTR_INSTANCE_VALUE', 180) -def_op(loc, 'LOAD_ATTR_METHOD_LAZY_DICT', 181) -def_op(loc, 'LOAD_ATTR_METHOD_NO_DICT', 182) -def_op(loc, 'LOAD_ATTR_METHOD_WITH_VALUES', 183) -def_op(loc, 'LOAD_ATTR_MODULE', 184) -def_op(loc, 'LOAD_ATTR_NONDESCRIPTOR_NO_DICT', 185) -def_op(loc, 'LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES', 186) -def_op(loc, 'LOAD_ATTR_PROPERTY', 187) -def_op(loc, 'LOAD_ATTR_SLOT', 188) -def_op(loc, 'LOAD_ATTR_WITH_HINT', 189) -def_op(loc, 'LOAD_CONST_IMMORTAL', 190) -def_op(loc, 'LOAD_CONST_MORTAL', 191) -def_op(loc, 'LOAD_GLOBAL_BUILTIN', 192) -def_op(loc, 'LOAD_GLOBAL_MODULE', 193) -def_op(loc, 'LOAD_SUPER_ATTR_ATTR', 194) -def_op(loc, 'LOAD_SUPER_ATTR_METHOD', 195) -def_op(loc, 'RESUME_CHECK', 196) -def_op(loc, 'SEND_GEN', 197) -def_op(loc, 'STORE_ATTR_INSTANCE_VALUE', 198) -def_op(loc, 'STORE_ATTR_SLOT', 199) -def_op(loc, 'STORE_ATTR_WITH_HINT', 200) -def_op(loc, 'STORE_SUBSCR_DICT', 201) -def_op(loc, 'STORE_SUBSCR_LIST_INT', 202) -def_op(loc, 'TO_BOOL_ALWAYS_TRUE', 203) -def_op(loc, 'TO_BOOL_BOOL', 204) -def_op(loc, 'TO_BOOL_INT', 205) -def_op(loc, 'TO_BOOL_LIST', 206) -def_op(loc, 'TO_BOOL_NONE', 207) -def_op(loc, 'TO_BOOL_STR', 208) -def_op(loc, 'UNPACK_SEQUENCE_LIST', 209) -def_op(loc, 'UNPACK_SEQUENCE_TUPLE', 210) -def_op(loc, 'UNPACK_SEQUENCE_TWO_TUPLE', 211) -def_op(loc, 'INSTRUMENTED_END_FOR', 234) -def_op(loc, 'INSTRUMENTED_POP_ITER', 235) -def_op(loc, 'INSTRUMENTED_END_SEND', 236) -def_op(loc, 'INSTRUMENTED_FOR_ITER', 237) -def_op(loc, 'INSTRUMENTED_INSTRUCTION', 238) -def_op(loc, 'INSTRUMENTED_JUMP_FORWARD', 239) -def_op(loc, 'INSTRUMENTED_NOT_TAKEN', 240) -def_op(loc, 'INSTRUMENTED_POP_JUMP_IF_TRUE', 241) -def_op(loc, 'INSTRUMENTED_POP_JUMP_IF_FALSE', 242) -def_op(loc, 'INSTRUMENTED_POP_JUMP_IF_NONE', 243) -def_op(loc, 'INSTRUMENTED_POP_JUMP_IF_NOT_NONE', 244) -def_op(loc, 'INSTRUMENTED_RESUME', 245) -def_op(loc, 'INSTRUMENTED_RETURN_VALUE', 246) -def_op(loc, 'INSTRUMENTED_YIELD_VALUE', 247) -def_op(loc, 'INSTRUMENTED_END_ASYNC_FOR', 248) -def_op(loc, 'INSTRUMENTED_LOAD_SUPER_ATTR', 249) -def_op(loc, 'INSTRUMENTED_CALL', 250) -def_op(loc, 'INSTRUMENTED_CALL_KW', 251) -def_op(loc, 'INSTRUMENTED_CALL_FUNCTION_EX', 252) -def_op(loc, 'INSTRUMENTED_JUMP_BACKWARD', 253) -def_op(loc, 'ENTER_EXECUTOR', 255) -def_op(loc, 'ANNOTATIONS_PLACEHOLDER', 256) -def_op(loc, 'JUMP', 257) -def_op(loc, 'JUMP_IF_FALSE', 258) -def_op(loc, 'JUMP_IF_TRUE', 259) -def_op(loc, 'JUMP_NO_INTERRUPT', 260) -def_op(loc, 'LOAD_CLOSURE', 261) -def_op(loc, 'POP_BLOCK', 262) -def_op(loc, 'SETUP_CLEANUP', 263) -def_op(loc, 'SETUP_FINALLY', 264) -def_op(loc, 'SETUP_WITH', 265) -def_op(loc, 'STORE_FAST_MAYBE_NULL', 266) +# Specialized opcodes (>128) +binary_op(loc, "BINARY_OP_ADD_FLOAT", 129, 2, 1) +binary_op(loc, "BINARY_OP_ADD_INT", 130, 2, 1) +binary_op(loc, "BINARY_OP_ADD_UNICODE", 131, 2, 1) +binary_op(loc, "BINARY_OP_EXTEND", 132, 2, 1) +binary_op(loc, "BINARY_OP_MULTIPLY_FLOAT", 133, 2, 1) +binary_op(loc, "BINARY_OP_MULTIPLY_INT", 134, 2, 1) +binary_op(loc, "BINARY_OP_SUBSCR_DICT", 135, 2, 1) +binary_op(loc, "BINARY_OP_SUBSCR_GETITEM", 136, 2, 0) +binary_op(loc, "BINARY_OP_SUBSCR_LIST_INT", 137, 2, 1) +binary_op(loc, "BINARY_OP_SUBSCR_LIST_SLICE", 138, 2, 1) +binary_op(loc, "BINARY_OP_SUBSCR_STR_INT", 139, 2, 1) +binary_op(loc, "BINARY_OP_SUBSCR_TUPLE_INT", 140, 2, 1) +binary_op(loc, "BINARY_OP_SUBTRACT_FLOAT", 141, 2, 1) +binary_op(loc, "BINARY_OP_SUBTRACT_INT", 142, 2, 1) +call_op(loc, "CALL_ALLOC_AND_ENTER_INIT", 143, -2, 0) # pops 2 + oparg +call_op(loc, "CALL_BOUND_METHOD_EXACT_ARGS", 144, -2, 0) # pops 2 + oparg +call_op(loc, "CALL_BOUND_METHOD_GENERAL", 145, -2, 0) # pops 2 + oparg +call_op(loc, "CALL_BUILTIN_CLASS", 146, -2, 1) # pops 2 + oparg +call_op(loc, "CALL_BUILTIN_FAST", 147, -2, 1) # pops 2 + oparg +call_op(loc, "CALL_BUILTIN_FAST_WITH_KEYWORDS", 148, -2, 1) # pops 2 + oparg +call_op(loc, "CALL_BUILTIN_O", 149, -2, 1) # pops 2 + oparg +def_op(loc, "CALL_ISINSTANCE", 150, 4, 1) +call_op(loc, "CALL_KW_BOUND_METHOD", 151, -3, 0) # pops 3 + oparg +call_op(loc, "CALL_KW_NON_PY", 152, -3, 1) # pops 3 + oparg +call_op(loc, "CALL_KW_PY", 153, -3, 0) # pops 3 + oparg +def_op(loc, "CALL_LEN", 154, 3, 1) +def_op(loc, "CALL_LIST_APPEND", 155, 3, 0) +call_op(loc, "CALL_METHOD_DESCRIPTOR_FAST", 156, -2, 1) # pops 2 + oparg +call_op(loc, "CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", 157, -2, 1) # pops 2 + oparg +call_op(loc, "CALL_METHOD_DESCRIPTOR_NOARGS", 158, -2, 1) # pops 2 + oparg +call_op(loc, "CALL_METHOD_DESCRIPTOR_O", 159, -2, 1) # pops 2 + oparg +call_op(loc, "CALL_NON_PY_GENERAL", 160, -2, 1) # pops 2 + oparg +call_op(loc, "CALL_PY_EXACT_ARGS", 161, -2, 0) # pops 2 + oparg +call_op(loc, "CALL_PY_GENERAL", 162, -2, 0) # pops 2 + oparg +def_op(loc, "CALL_STR_1", 163, 3, 1) +def_op(loc, "CALL_TUPLE_1", 164, 3, 1) +def_op(loc, "CALL_TYPE_1", 165, 3, 1) +compare_op(loc, "COMPARE_OP_FLOAT", 166, 2, 1) +compare_op(loc, "COMPARE_OP_INT", 167, 2, 1) +compare_op(loc, "COMPARE_OP_STR", 168, 2, 1) +def_op(loc, "CONTAINS_OP_DICT", 169, 2, 1) +def_op(loc, "CONTAINS_OP_SET", 170, 2, 1) +jrel_op(loc, "FOR_ITER_GEN", 171, 2, 2, conditional=True) +jrel_op(loc, "FOR_ITER_LIST", 172, 2, 3, conditional=True) +jrel_op(loc, "FOR_ITER_RANGE", 173, 2, 3, conditional=True) +jrel_op(loc, "FOR_ITER_TUPLE", 174, 2, 3, conditional=True) +jrel_op(loc, "JUMP_BACKWARD_JIT", 175, 0, 0, conditional=False) +jrel_op(loc, "JUMP_BACKWARD_NO_JIT", 176, 0, 0, conditional=False) +def_op(loc, "LOAD_ATTR_CLASS", 177, 1, 1) # pushes 1 + (oparg & 1) +def_op(loc, "LOAD_ATTR_CLASS_WITH_METACLASS_CHECK", 178, 1, 1) # pushes 1 + (oparg & 1) +name_op(loc, "LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN", 179, 1, 1) +def_op(loc, "LOAD_ATTR_INSTANCE_VALUE", 180, 1, 1) # pushes 1 + (oparg & 1) +def_op(loc, "LOAD_ATTR_METHOD_LAZY_DICT", 181, 1, 2) +def_op(loc, "LOAD_ATTR_METHOD_NO_DICT", 182, 1, 2) +def_op(loc, "LOAD_ATTR_METHOD_WITH_VALUES", 183, 1, 2) +def_op(loc, "LOAD_ATTR_MODULE", 184, 1, 1) # pushes 1 + (oparg & 1) +def_op(loc, "LOAD_ATTR_NONDESCRIPTOR_NO_DICT", 185, 1, 1) +def_op(loc, "LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES", 186, 1, 1) +def_op(loc, "LOAD_ATTR_PROPERTY", 187, 1, 0) +def_op(loc, "LOAD_ATTR_SLOT", 188, 1, 1) # pushes 1 + (oparg & 1) +name_op(loc, "LOAD_ATTR_WITH_HINT", 189, 1, 1) # pushes 1 + (oparg & 1) +def_op(loc, "LOAD_GLOBAL_BUILTIN", 190, 0, 1) # pushes 1 + (oparg & 1) +def_op(loc, "LOAD_GLOBAL_MODULE", 191, 0, 1) # pushes 1 + (oparg & 1) +name_op(loc, "LOAD_SUPER_ATTR_ATTR", 192, 3, 1) +name_op(loc, "LOAD_SUPER_ATTR_METHOD", 193, 3, 2) +def_op(loc, "RESUME_CHECK", 194, 0, 0) +def_op(loc, "SEND_GEN", 195, 2, 1) +def_op(loc, "STORE_ATTR_INSTANCE_VALUE", 196, 2, 0) +def_op(loc, "STORE_ATTR_SLOT", 197, 2, 0) +store_op(loc, "STORE_ATTR_WITH_HINT", 198, 2, 0, is_type="name") +def_op(loc, "STORE_SUBSCR_DICT", 199, 3, 0) +def_op(loc, "STORE_SUBSCR_LIST_INT", 200, 3, 0) +def_op(loc, "TO_BOOL_ALWAYS_TRUE", 201, 1, 1) +def_op(loc, "TO_BOOL_BOOL", 202, 1, 1) +def_op(loc, "TO_BOOL_INT", 203, 1, 1) +def_op(loc, "TO_BOOL_LIST", 204, 1, 1) +def_op(loc, "TO_BOOL_NONE", 205, 1, 1) +def_op(loc, "TO_BOOL_STR", 206, 1, 1) +varargs_op(loc, "UNPACK_SEQUENCE_LIST", 207, 1, -1) +varargs_op(loc, "UNPACK_SEQUENCE_TUPLE", 208, 1, -1) +def_op(loc, "UNPACK_SEQUENCE_TWO_TUPLE", 209, 1, 2) +def_op(loc, "INSTRUMENTED_END_FOR", 233, 3, 2) +def_op(loc, "INSTRUMENTED_POP_ITER", 234, 2, 0) +def_op(loc, "INSTRUMENTED_END_SEND", 235, 2, 1) +jrel_op(loc, "INSTRUMENTED_FOR_ITER", 236, 2, 3, conditional=True) +def_op(loc, "INSTRUMENTED_INSTRUCTION", 237, 0, 0) +jrel_op(loc, "INSTRUMENTED_JUMP_FORWARD", 238, 0, 0, conditional=False) +def_op(loc, "INSTRUMENTED_NOT_TAKEN", 239, 0, 0) +jrel_op(loc, "INSTRUMENTED_POP_JUMP_IF_TRUE", 240, 1, 0, conditional=True) +jrel_op(loc, "INSTRUMENTED_POP_JUMP_IF_FALSE", 241, 1, 0, conditional=True) +jrel_op(loc, "INSTRUMENTED_POP_JUMP_IF_NONE", 242, 1, 0, conditional=True) +jrel_op(loc, "INSTRUMENTED_POP_JUMP_IF_NOT_NONE", 243, 1, 0, conditional=True) +def_op(loc, "INSTRUMENTED_RESUME", 244, 0, 0) +def_op(loc, "INSTRUMENTED_RETURN_VALUE", 245, 1, 1) +def_op(loc, "INSTRUMENTED_YIELD_VALUE", 246, 1, 1) +jrel_op(loc, "INSTRUMENTED_END_ASYNC_FOR", 247, 2, 0, conditional=True) +name_op(loc, "INSTRUMENTED_LOAD_SUPER_ATTR", 248, 3, 1) # pushes 1 + (oparg & 1) +call_op(loc, "INSTRUMENTED_CALL", 249, -2, 1) +call_op(loc, "INSTRUMENTED_CALL_KW", 250, -3, 1) +def_op(loc, "INSTRUMENTED_CALL_FUNCTION_EX", 251, 4, 1) +jrel_op(loc, "INSTRUMENTED_JUMP_BACKWARD", 252, 0, 0, conditional=False) +def_op(loc, "INSTRUMENTED_LINE", 253, 0, 0) +def_op(loc, "ENTER_EXECUTOR", 254, 0, 0) +def_op(loc, "TRACE_RECORD", 255, 0, 0) +def_op(loc, "ANNOTATIONS_PLACEHOLDER", 256, 0, 0) +jrel_op(loc, "JUMP", 257, 0, 0, conditional=False) +jrel_op(loc, "JUMP_IF_FALSE", 258, 1, 1, conditional=True) +jrel_op(loc, "JUMP_IF_TRUE", 259, 1, 1, conditional=True) +jrel_op(loc, "JUMP_NO_INTERRUPT", 260, 0, 0, conditional=False) +local_op(loc, "LOAD_CLOSURE", 261, 0, 1) +def_op(loc, "POP_BLOCK", 262, 0, 0) +def_op(loc, "SETUP_CLEANUP", 263, 0, 2) +def_op(loc, "SETUP_FINALLY", 264, 0, 1) +def_op(loc, "SETUP_WITH", 265, 0, 1) +def_op(loc, "STORE_FAST_MAYBE_NULL", 266, 1, 0) # ops >= 44 have args HAVE_ARGUMENT = 44 -loc["hasarg"] = [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 128, 237, 239, 241, 242, 243, 244, 245, 247, 248, 249, 250, 251, 253, 255, 257, 258, 259, 260, 261, 263, 264, 265, 266] -loc["hascompare"] = [56] -loc["hasconst"] = [82] -loc["hasexc"] = [263, 264, 265] -loc["hasfree"] = [62, 90, 97, 111] -loc["hasjabs"] = [] -loc["hasjrel"] = [68, 70, 75, 76, 77, 100, 101, 102, 103, 106, 237, 248, 257, 258, 259, 260] -loc["hasjump"] = [68, 70, 75, 76, 77, 100, 101, 102, 103, 106, 237, 248, 257, 258, 259, 260] -loc["haslocal"] = [63, 83, 84, 85, 86, 87, 88, 89, 112, 113, 114, 261, 266] -loc["hasname"] = [61, 64, 65, 72, 73, 80, 91, 92, 93, 96, 110, 115, 116, 249] +loc["hasarg"] = [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 128, 143, 144, 145, 146, 147, 148, 149, 151, 152, 153, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 195, 198, 207, 208, 209, 236, 238, 240, 241, 242, 243, 244, 246, 247, 248, 249, 250, 252, 254, 255, 257, 258, 259, 260, 261, 263, 264, 265, 266] +# hasconst table populated by const_op definitions +# hasname table populated by name_op and store_op definitions +# jrel table populated by jrel_op definitions +loc["hasjabs"] = [] +loc["hasjump"] = loc["hasjrel"] +# hasfree table populated by free_op and store_op definitions +# haslocal table populated by local_op and store_op definitions +loc["hasexc"] = [263, 264, 265] ### update formatting import xdis.opcodes.opcode_313 as opcode_313 @@ -459,15 +333,27 @@ def extended_BINARY_OP_314(opc, instructions): fmt_str = "%s[%s]" if opname == "[]" else f"%s {opname} %s" return extended_format_binary_op(opc, instructions, fmt_str) +_common_constants = [ + "AssertionError", + "NotImplementedError", + "tuple", + "all", + "any" +] + +def format_LOAD_COMMON_CONSTANT_314(arg: int): + return _common_constants[arg] opcode_arg_fmt = opcode_arg_fmt314 = { **opcode_313.opcode_arg_fmt313, **{"BINARY_OP": format_BINARY_OP_314}, + **{"LOAD_COMMON_CONSTANT": format_LOAD_COMMON_CONSTANT_314}, } opcode_extended_fmt = opcode_extended_fmt314 = { **opcode_313.opcode_extended_fmt313, **{"BINARY_OP": extended_BINARY_OP_314}, + **{"LOAD_COMMON_CONSTANT": format_LOAD_COMMON_CONSTANT_314}, } findlinestarts = opcode_313.findlinestarts_313 diff --git a/xdis/unmarshal.py b/xdis/unmarshal.py index 4fd61157..66bf6c70 100644 --- a/xdis/unmarshal.py +++ b/xdis/unmarshal.py @@ -89,6 +89,7 @@ def long(n: int) -> LongTypeForPython3: "[": "list", "<": "frozenset", ">": "set", + ":": "slice", "{": "dict", "R": "python2_string_reference", "c": "code", @@ -152,7 +153,9 @@ def __init__(self, fp, magic_int, bytes_for_s, code_objects={}) -> None: self.bytes_for_s = bytes_for_s version = magic_int2tuple(self.magic_int) - if version >= (3, 4): + if version >= (3, 14): + self.marshal_version = 5 + elif (3, 14) > version >= (3, 4): if self.magic_int in (3250, 3260, 3270): self.marshal_version = 3 else: @@ -454,9 +457,26 @@ def t_python2_string_reference(self, save_ref, bytes_for_s: bool = False): refnum = unpack("= (1, 5): if self.version_tuple >= (2, 3): co_firstlineno = unpack(" tuple: if isinstance(fp, bytes): fp = io.BytesIO(fp)