diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 38f290df2c770f..9fe14298dfb01f 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -394,889 +394,1279 @@ extern "C" { #define _WITH_EXCEPT_START WITH_EXCEPT_START #define _YIELD_VALUE YIELD_VALUE #define MAX_UOP_ID 593 +#define MAX_CACHED_REGISTER 3 #define _BINARY_OP_r23 594 #define _BINARY_OP_ADD_FLOAT_r03 595 #define _BINARY_OP_ADD_FLOAT_r13 596 #define _BINARY_OP_ADD_FLOAT_r23 597 -#define _BINARY_OP_ADD_INT_r03 598 -#define _BINARY_OP_ADD_INT_r13 599 -#define _BINARY_OP_ADD_INT_r23 600 -#define _BINARY_OP_ADD_UNICODE_r03 601 -#define _BINARY_OP_ADD_UNICODE_r13 602 -#define _BINARY_OP_ADD_UNICODE_r23 603 -#define _BINARY_OP_EXTEND_r23 604 -#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 605 -#define _BINARY_OP_MULTIPLY_FLOAT_r03 606 -#define _BINARY_OP_MULTIPLY_FLOAT_r13 607 -#define _BINARY_OP_MULTIPLY_FLOAT_r23 608 -#define _BINARY_OP_MULTIPLY_INT_r03 609 -#define _BINARY_OP_MULTIPLY_INT_r13 610 -#define _BINARY_OP_MULTIPLY_INT_r23 611 -#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 612 -#define _BINARY_OP_SUBSCR_DICT_r23 613 -#define _BINARY_OP_SUBSCR_INIT_CALL_r01 614 -#define _BINARY_OP_SUBSCR_INIT_CALL_r11 615 -#define _BINARY_OP_SUBSCR_INIT_CALL_r21 616 -#define _BINARY_OP_SUBSCR_INIT_CALL_r31 617 -#define _BINARY_OP_SUBSCR_LIST_INT_r23 618 -#define _BINARY_OP_SUBSCR_LIST_SLICE_r23 619 -#define _BINARY_OP_SUBSCR_STR_INT_r23 620 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 621 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 622 -#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 623 -#define _BINARY_OP_SUBSCR_USTR_INT_r23 624 -#define _BINARY_OP_SUBTRACT_FLOAT_r03 625 -#define _BINARY_OP_SUBTRACT_FLOAT_r13 626 -#define _BINARY_OP_SUBTRACT_FLOAT_r23 627 -#define _BINARY_OP_SUBTRACT_INT_r03 628 -#define _BINARY_OP_SUBTRACT_INT_r13 629 -#define _BINARY_OP_SUBTRACT_INT_r23 630 -#define _BINARY_SLICE_r31 631 -#define _BUILD_INTERPOLATION_r01 632 -#define _BUILD_LIST_r01 633 -#define _BUILD_MAP_r01 634 -#define _BUILD_SET_r01 635 -#define _BUILD_SLICE_r01 636 -#define _BUILD_STRING_r01 637 -#define _BUILD_TEMPLATE_r21 638 -#define _BUILD_TUPLE_r01 639 -#define _CALL_BUILTIN_CLASS_r01 640 -#define _CALL_BUILTIN_FAST_r01 641 -#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r01 642 -#define _CALL_BUILTIN_O_r03 643 -#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 644 -#define _CALL_INTRINSIC_1_r11 645 -#define _CALL_INTRINSIC_2_r21 646 -#define _CALL_ISINSTANCE_r31 647 -#define _CALL_KW_NON_PY_r11 648 -#define _CALL_LEN_r33 649 -#define _CALL_LIST_APPEND_r03 650 -#define _CALL_LIST_APPEND_r13 651 -#define _CALL_LIST_APPEND_r23 652 -#define _CALL_LIST_APPEND_r33 653 -#define _CALL_METHOD_DESCRIPTOR_FAST_r01 654 -#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01 655 -#define _CALL_METHOD_DESCRIPTOR_NOARGS_r01 656 -#define _CALL_METHOD_DESCRIPTOR_O_r03 657 -#define _CALL_NON_PY_GENERAL_r01 658 -#define _CALL_STR_1_r32 659 -#define _CALL_TUPLE_1_r32 660 -#define _CALL_TYPE_1_r02 661 -#define _CALL_TYPE_1_r12 662 -#define _CALL_TYPE_1_r22 663 -#define _CALL_TYPE_1_r32 664 -#define _CHECK_AND_ALLOCATE_OBJECT_r00 665 -#define _CHECK_ATTR_CLASS_r01 666 -#define _CHECK_ATTR_CLASS_r11 667 -#define _CHECK_ATTR_CLASS_r22 668 -#define _CHECK_ATTR_CLASS_r33 669 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 670 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 671 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 672 -#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 673 -#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 674 -#define _CHECK_EG_MATCH_r22 675 -#define _CHECK_EXC_MATCH_r22 676 -#define _CHECK_FUNCTION_EXACT_ARGS_r00 677 -#define _CHECK_FUNCTION_VERSION_r00 678 -#define _CHECK_FUNCTION_VERSION_INLINE_r00 679 -#define _CHECK_FUNCTION_VERSION_INLINE_r11 680 -#define _CHECK_FUNCTION_VERSION_INLINE_r22 681 -#define _CHECK_FUNCTION_VERSION_INLINE_r33 682 -#define _CHECK_FUNCTION_VERSION_KW_r11 683 -#define _CHECK_IS_NOT_PY_CALLABLE_r00 684 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r03 685 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r13 686 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r23 687 -#define _CHECK_IS_NOT_PY_CALLABLE_EX_r33 688 -#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 689 -#define _CHECK_IS_PY_CALLABLE_EX_r03 690 -#define _CHECK_IS_PY_CALLABLE_EX_r13 691 -#define _CHECK_IS_PY_CALLABLE_EX_r23 692 -#define _CHECK_IS_PY_CALLABLE_EX_r33 693 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 694 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 695 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 696 -#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 697 -#define _CHECK_METHOD_VERSION_r00 698 -#define _CHECK_METHOD_VERSION_KW_r11 699 -#define _CHECK_PEP_523_r00 700 -#define _CHECK_PEP_523_r11 701 -#define _CHECK_PEP_523_r22 702 -#define _CHECK_PEP_523_r33 703 -#define _CHECK_PERIODIC_r00 704 -#define _CHECK_PERIODIC_AT_END_r00 705 -#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 706 -#define _CHECK_RECURSION_REMAINING_r00 707 -#define _CHECK_RECURSION_REMAINING_r11 708 -#define _CHECK_RECURSION_REMAINING_r22 709 -#define _CHECK_RECURSION_REMAINING_r33 710 -#define _CHECK_STACK_SPACE_r00 711 -#define _CHECK_STACK_SPACE_OPERAND_r00 712 -#define _CHECK_STACK_SPACE_OPERAND_r11 713 -#define _CHECK_STACK_SPACE_OPERAND_r22 714 -#define _CHECK_STACK_SPACE_OPERAND_r33 715 -#define _CHECK_VALIDITY_r00 716 -#define _CHECK_VALIDITY_r11 717 -#define _CHECK_VALIDITY_r22 718 -#define _CHECK_VALIDITY_r33 719 -#define _COLD_DYNAMIC_EXIT_r00 720 -#define _COLD_EXIT_r00 721 -#define _COMPARE_OP_r21 722 -#define _COMPARE_OP_FLOAT_r03 723 -#define _COMPARE_OP_FLOAT_r13 724 -#define _COMPARE_OP_FLOAT_r23 725 -#define _COMPARE_OP_INT_r23 726 -#define _COMPARE_OP_STR_r23 727 -#define _CONTAINS_OP_r23 728 -#define _CONTAINS_OP_DICT_r23 729 -#define _CONTAINS_OP_SET_r23 730 -#define _CONVERT_VALUE_r11 731 -#define _COPY_r01 732 -#define _COPY_1_r02 733 -#define _COPY_1_r12 734 -#define _COPY_1_r23 735 -#define _COPY_2_r03 736 -#define _COPY_2_r13 737 -#define _COPY_2_r23 738 -#define _COPY_3_r03 739 -#define _COPY_3_r13 740 -#define _COPY_3_r23 741 -#define _COPY_3_r33 742 -#define _COPY_FREE_VARS_r00 743 -#define _COPY_FREE_VARS_r11 744 -#define _COPY_FREE_VARS_r22 745 -#define _COPY_FREE_VARS_r33 746 -#define _CREATE_INIT_FRAME_r01 747 -#define _DELETE_ATTR_r10 748 -#define _DELETE_DEREF_r00 749 -#define _DELETE_FAST_r00 750 -#define _DELETE_GLOBAL_r00 751 -#define _DELETE_NAME_r00 752 -#define _DELETE_SUBSCR_r20 753 -#define _DEOPT_r00 754 -#define _DEOPT_r10 755 -#define _DEOPT_r20 756 -#define _DEOPT_r30 757 -#define _DICT_MERGE_r10 758 -#define _DICT_UPDATE_r10 759 -#define _DO_CALL_r01 760 -#define _DO_CALL_FUNCTION_EX_r31 761 -#define _DO_CALL_KW_r11 762 -#define _DYNAMIC_EXIT_r00 763 -#define _DYNAMIC_EXIT_r10 764 -#define _DYNAMIC_EXIT_r20 765 -#define _DYNAMIC_EXIT_r30 766 -#define _END_FOR_r10 767 -#define _END_SEND_r21 768 -#define _ERROR_POP_N_r00 769 -#define _EXIT_INIT_CHECK_r10 770 -#define _EXIT_TRACE_r00 771 -#define _EXIT_TRACE_r10 772 -#define _EXIT_TRACE_r20 773 -#define _EXIT_TRACE_r30 774 -#define _EXPAND_METHOD_r00 775 -#define _EXPAND_METHOD_KW_r11 776 -#define _FATAL_ERROR_r00 777 -#define _FATAL_ERROR_r11 778 -#define _FATAL_ERROR_r22 779 -#define _FATAL_ERROR_r33 780 -#define _FORMAT_SIMPLE_r11 781 -#define _FORMAT_WITH_SPEC_r21 782 -#define _FOR_ITER_r23 783 -#define _FOR_ITER_GEN_FRAME_r03 784 -#define _FOR_ITER_GEN_FRAME_r13 785 -#define _FOR_ITER_GEN_FRAME_r23 786 -#define _FOR_ITER_TIER_TWO_r23 787 -#define _GET_AITER_r11 788 -#define _GET_ANEXT_r12 789 -#define _GET_AWAITABLE_r11 790 -#define _GET_ITER_r12 791 -#define _GET_LEN_r12 792 -#define _GET_YIELD_FROM_ITER_r11 793 -#define _GUARD_BINARY_OP_EXTEND_r22 794 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 795 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 796 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 797 -#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 798 -#define _GUARD_BIT_IS_SET_POP_r00 799 -#define _GUARD_BIT_IS_SET_POP_r10 800 -#define _GUARD_BIT_IS_SET_POP_r21 801 -#define _GUARD_BIT_IS_SET_POP_r32 802 -#define _GUARD_BIT_IS_SET_POP_4_r00 803 -#define _GUARD_BIT_IS_SET_POP_4_r10 804 -#define _GUARD_BIT_IS_SET_POP_4_r21 805 -#define _GUARD_BIT_IS_SET_POP_4_r32 806 -#define _GUARD_BIT_IS_SET_POP_5_r00 807 -#define _GUARD_BIT_IS_SET_POP_5_r10 808 -#define _GUARD_BIT_IS_SET_POP_5_r21 809 -#define _GUARD_BIT_IS_SET_POP_5_r32 810 -#define _GUARD_BIT_IS_SET_POP_6_r00 811 -#define _GUARD_BIT_IS_SET_POP_6_r10 812 -#define _GUARD_BIT_IS_SET_POP_6_r21 813 -#define _GUARD_BIT_IS_SET_POP_6_r32 814 -#define _GUARD_BIT_IS_SET_POP_7_r00 815 -#define _GUARD_BIT_IS_SET_POP_7_r10 816 -#define _GUARD_BIT_IS_SET_POP_7_r21 817 -#define _GUARD_BIT_IS_SET_POP_7_r32 818 -#define _GUARD_BIT_IS_UNSET_POP_r00 819 -#define _GUARD_BIT_IS_UNSET_POP_r10 820 -#define _GUARD_BIT_IS_UNSET_POP_r21 821 -#define _GUARD_BIT_IS_UNSET_POP_r32 822 -#define _GUARD_BIT_IS_UNSET_POP_4_r00 823 -#define _GUARD_BIT_IS_UNSET_POP_4_r10 824 -#define _GUARD_BIT_IS_UNSET_POP_4_r21 825 -#define _GUARD_BIT_IS_UNSET_POP_4_r32 826 -#define _GUARD_BIT_IS_UNSET_POP_5_r00 827 -#define _GUARD_BIT_IS_UNSET_POP_5_r10 828 -#define _GUARD_BIT_IS_UNSET_POP_5_r21 829 -#define _GUARD_BIT_IS_UNSET_POP_5_r32 830 -#define _GUARD_BIT_IS_UNSET_POP_6_r00 831 -#define _GUARD_BIT_IS_UNSET_POP_6_r10 832 -#define _GUARD_BIT_IS_UNSET_POP_6_r21 833 -#define _GUARD_BIT_IS_UNSET_POP_6_r32 834 -#define _GUARD_BIT_IS_UNSET_POP_7_r00 835 -#define _GUARD_BIT_IS_UNSET_POP_7_r10 836 -#define _GUARD_BIT_IS_UNSET_POP_7_r21 837 -#define _GUARD_BIT_IS_UNSET_POP_7_r32 838 -#define _GUARD_CALLABLE_ISINSTANCE_r03 839 -#define _GUARD_CALLABLE_ISINSTANCE_r13 840 -#define _GUARD_CALLABLE_ISINSTANCE_r23 841 -#define _GUARD_CALLABLE_ISINSTANCE_r33 842 -#define _GUARD_CALLABLE_LEN_r03 843 -#define _GUARD_CALLABLE_LEN_r13 844 -#define _GUARD_CALLABLE_LEN_r23 845 -#define _GUARD_CALLABLE_LEN_r33 846 -#define _GUARD_CALLABLE_LIST_APPEND_r03 847 -#define _GUARD_CALLABLE_LIST_APPEND_r13 848 -#define _GUARD_CALLABLE_LIST_APPEND_r23 849 -#define _GUARD_CALLABLE_LIST_APPEND_r33 850 -#define _GUARD_CALLABLE_STR_1_r03 851 -#define _GUARD_CALLABLE_STR_1_r13 852 -#define _GUARD_CALLABLE_STR_1_r23 853 -#define _GUARD_CALLABLE_STR_1_r33 854 -#define _GUARD_CALLABLE_TUPLE_1_r03 855 -#define _GUARD_CALLABLE_TUPLE_1_r13 856 -#define _GUARD_CALLABLE_TUPLE_1_r23 857 -#define _GUARD_CALLABLE_TUPLE_1_r33 858 -#define _GUARD_CALLABLE_TYPE_1_r03 859 -#define _GUARD_CALLABLE_TYPE_1_r13 860 -#define _GUARD_CALLABLE_TYPE_1_r23 861 -#define _GUARD_CALLABLE_TYPE_1_r33 862 -#define _GUARD_CODE_VERSION_r00 863 -#define _GUARD_CODE_VERSION_r11 864 -#define _GUARD_CODE_VERSION_r22 865 -#define _GUARD_CODE_VERSION_r33 866 -#define _GUARD_DORV_NO_DICT_r01 867 -#define _GUARD_DORV_NO_DICT_r11 868 -#define _GUARD_DORV_NO_DICT_r22 869 -#define _GUARD_DORV_NO_DICT_r33 870 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 871 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 872 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 873 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 874 -#define _GUARD_GLOBALS_VERSION_r00 875 -#define _GUARD_GLOBALS_VERSION_r11 876 -#define _GUARD_GLOBALS_VERSION_r22 877 -#define _GUARD_GLOBALS_VERSION_r33 878 -#define _GUARD_IP_RETURN_GENERATOR_r00 879 -#define _GUARD_IP_RETURN_GENERATOR_r11 880 -#define _GUARD_IP_RETURN_GENERATOR_r22 881 -#define _GUARD_IP_RETURN_GENERATOR_r33 882 -#define _GUARD_IP_RETURN_VALUE_r00 883 -#define _GUARD_IP_RETURN_VALUE_r11 884 -#define _GUARD_IP_RETURN_VALUE_r22 885 -#define _GUARD_IP_RETURN_VALUE_r33 886 -#define _GUARD_IP_YIELD_VALUE_r00 887 -#define _GUARD_IP_YIELD_VALUE_r11 888 -#define _GUARD_IP_YIELD_VALUE_r22 889 -#define _GUARD_IP_YIELD_VALUE_r33 890 -#define _GUARD_IP__PUSH_FRAME_r00 891 -#define _GUARD_IP__PUSH_FRAME_r11 892 -#define _GUARD_IP__PUSH_FRAME_r22 893 -#define _GUARD_IP__PUSH_FRAME_r33 894 -#define _GUARD_IS_FALSE_POP_r00 895 -#define _GUARD_IS_FALSE_POP_r10 896 -#define _GUARD_IS_FALSE_POP_r21 897 -#define _GUARD_IS_FALSE_POP_r32 898 -#define _GUARD_IS_NONE_POP_r00 899 -#define _GUARD_IS_NONE_POP_r10 900 -#define _GUARD_IS_NONE_POP_r21 901 -#define _GUARD_IS_NONE_POP_r32 902 -#define _GUARD_IS_NOT_NONE_POP_r10 903 -#define _GUARD_IS_TRUE_POP_r00 904 -#define _GUARD_IS_TRUE_POP_r10 905 -#define _GUARD_IS_TRUE_POP_r21 906 -#define _GUARD_IS_TRUE_POP_r32 907 -#define _GUARD_KEYS_VERSION_r01 908 -#define _GUARD_KEYS_VERSION_r11 909 -#define _GUARD_KEYS_VERSION_r22 910 -#define _GUARD_KEYS_VERSION_r33 911 -#define _GUARD_NOS_ANY_DICT_r02 912 -#define _GUARD_NOS_ANY_DICT_r12 913 -#define _GUARD_NOS_ANY_DICT_r22 914 -#define _GUARD_NOS_ANY_DICT_r33 915 -#define _GUARD_NOS_COMPACT_ASCII_r02 916 -#define _GUARD_NOS_COMPACT_ASCII_r12 917 -#define _GUARD_NOS_COMPACT_ASCII_r22 918 -#define _GUARD_NOS_COMPACT_ASCII_r33 919 -#define _GUARD_NOS_DICT_r02 920 -#define _GUARD_NOS_DICT_r12 921 -#define _GUARD_NOS_DICT_r22 922 -#define _GUARD_NOS_DICT_r33 923 -#define _GUARD_NOS_FLOAT_r02 924 -#define _GUARD_NOS_FLOAT_r12 925 -#define _GUARD_NOS_FLOAT_r22 926 -#define _GUARD_NOS_FLOAT_r33 927 -#define _GUARD_NOS_INT_r02 928 -#define _GUARD_NOS_INT_r12 929 -#define _GUARD_NOS_INT_r22 930 -#define _GUARD_NOS_INT_r33 931 -#define _GUARD_NOS_LIST_r02 932 -#define _GUARD_NOS_LIST_r12 933 -#define _GUARD_NOS_LIST_r22 934 -#define _GUARD_NOS_LIST_r33 935 -#define _GUARD_NOS_NOT_NULL_r02 936 -#define _GUARD_NOS_NOT_NULL_r12 937 -#define _GUARD_NOS_NOT_NULL_r22 938 -#define _GUARD_NOS_NOT_NULL_r33 939 -#define _GUARD_NOS_NULL_r02 940 -#define _GUARD_NOS_NULL_r12 941 -#define _GUARD_NOS_NULL_r22 942 -#define _GUARD_NOS_NULL_r33 943 -#define _GUARD_NOS_OVERFLOWED_r02 944 -#define _GUARD_NOS_OVERFLOWED_r12 945 -#define _GUARD_NOS_OVERFLOWED_r22 946 -#define _GUARD_NOS_OVERFLOWED_r33 947 -#define _GUARD_NOS_TUPLE_r02 948 -#define _GUARD_NOS_TUPLE_r12 949 -#define _GUARD_NOS_TUPLE_r22 950 -#define _GUARD_NOS_TUPLE_r33 951 -#define _GUARD_NOS_UNICODE_r02 952 -#define _GUARD_NOS_UNICODE_r12 953 -#define _GUARD_NOS_UNICODE_r22 954 -#define _GUARD_NOS_UNICODE_r33 955 -#define _GUARD_NOT_EXHAUSTED_LIST_r02 956 -#define _GUARD_NOT_EXHAUSTED_LIST_r12 957 -#define _GUARD_NOT_EXHAUSTED_LIST_r22 958 -#define _GUARD_NOT_EXHAUSTED_LIST_r33 959 -#define _GUARD_NOT_EXHAUSTED_RANGE_r02 960 -#define _GUARD_NOT_EXHAUSTED_RANGE_r12 961 -#define _GUARD_NOT_EXHAUSTED_RANGE_r22 962 -#define _GUARD_NOT_EXHAUSTED_RANGE_r33 963 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 964 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 965 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 966 -#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 967 -#define _GUARD_THIRD_NULL_r03 968 -#define _GUARD_THIRD_NULL_r13 969 -#define _GUARD_THIRD_NULL_r23 970 -#define _GUARD_THIRD_NULL_r33 971 -#define _GUARD_TOS_ANY_DICT_r01 972 -#define _GUARD_TOS_ANY_DICT_r11 973 -#define _GUARD_TOS_ANY_DICT_r22 974 -#define _GUARD_TOS_ANY_DICT_r33 975 -#define _GUARD_TOS_ANY_SET_r01 976 -#define _GUARD_TOS_ANY_SET_r11 977 -#define _GUARD_TOS_ANY_SET_r22 978 -#define _GUARD_TOS_ANY_SET_r33 979 -#define _GUARD_TOS_DICT_r01 980 -#define _GUARD_TOS_DICT_r11 981 -#define _GUARD_TOS_DICT_r22 982 -#define _GUARD_TOS_DICT_r33 983 -#define _GUARD_TOS_FLOAT_r01 984 -#define _GUARD_TOS_FLOAT_r11 985 -#define _GUARD_TOS_FLOAT_r22 986 -#define _GUARD_TOS_FLOAT_r33 987 -#define _GUARD_TOS_FROZENDICT_r01 988 -#define _GUARD_TOS_FROZENDICT_r11 989 -#define _GUARD_TOS_FROZENDICT_r22 990 -#define _GUARD_TOS_FROZENDICT_r33 991 -#define _GUARD_TOS_FROZENSET_r01 992 -#define _GUARD_TOS_FROZENSET_r11 993 -#define _GUARD_TOS_FROZENSET_r22 994 -#define _GUARD_TOS_FROZENSET_r33 995 -#define _GUARD_TOS_INT_r01 996 -#define _GUARD_TOS_INT_r11 997 -#define _GUARD_TOS_INT_r22 998 -#define _GUARD_TOS_INT_r33 999 -#define _GUARD_TOS_LIST_r01 1000 -#define _GUARD_TOS_LIST_r11 1001 -#define _GUARD_TOS_LIST_r22 1002 -#define _GUARD_TOS_LIST_r33 1003 -#define _GUARD_TOS_OVERFLOWED_r01 1004 -#define _GUARD_TOS_OVERFLOWED_r11 1005 -#define _GUARD_TOS_OVERFLOWED_r22 1006 -#define _GUARD_TOS_OVERFLOWED_r33 1007 -#define _GUARD_TOS_SET_r01 1008 -#define _GUARD_TOS_SET_r11 1009 -#define _GUARD_TOS_SET_r22 1010 -#define _GUARD_TOS_SET_r33 1011 -#define _GUARD_TOS_SLICE_r01 1012 -#define _GUARD_TOS_SLICE_r11 1013 -#define _GUARD_TOS_SLICE_r22 1014 -#define _GUARD_TOS_SLICE_r33 1015 -#define _GUARD_TOS_TUPLE_r01 1016 -#define _GUARD_TOS_TUPLE_r11 1017 -#define _GUARD_TOS_TUPLE_r22 1018 -#define _GUARD_TOS_TUPLE_r33 1019 -#define _GUARD_TOS_UNICODE_r01 1020 -#define _GUARD_TOS_UNICODE_r11 1021 -#define _GUARD_TOS_UNICODE_r22 1022 -#define _GUARD_TOS_UNICODE_r33 1023 -#define _GUARD_TYPE_VERSION_r01 1024 -#define _GUARD_TYPE_VERSION_r11 1025 -#define _GUARD_TYPE_VERSION_r22 1026 -#define _GUARD_TYPE_VERSION_r33 1027 -#define _GUARD_TYPE_VERSION_AND_LOCK_r01 1028 -#define _GUARD_TYPE_VERSION_AND_LOCK_r11 1029 -#define _GUARD_TYPE_VERSION_AND_LOCK_r22 1030 -#define _GUARD_TYPE_VERSION_AND_LOCK_r33 1031 -#define _HANDLE_PENDING_AND_DEOPT_r00 1032 -#define _HANDLE_PENDING_AND_DEOPT_r10 1033 -#define _HANDLE_PENDING_AND_DEOPT_r20 1034 -#define _HANDLE_PENDING_AND_DEOPT_r30 1035 -#define _IMPORT_FROM_r12 1036 -#define _IMPORT_NAME_r21 1037 -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1038 -#define _INIT_CALL_PY_EXACT_ARGS_r01 1039 -#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1040 -#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1041 -#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1042 -#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1043 -#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1044 -#define _INSERT_1_LOAD_CONST_INLINE_r02 1045 -#define _INSERT_1_LOAD_CONST_INLINE_r12 1046 -#define _INSERT_1_LOAD_CONST_INLINE_r23 1047 -#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r02 1048 -#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r12 1049 -#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r23 1050 -#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r03 1051 -#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r13 1052 -#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r23 1053 -#define _INSERT_NULL_r10 1054 -#define _INSTRUMENTED_FOR_ITER_r23 1055 -#define _INSTRUMENTED_INSTRUCTION_r00 1056 -#define _INSTRUMENTED_JUMP_FORWARD_r00 1057 -#define _INSTRUMENTED_JUMP_FORWARD_r11 1058 -#define _INSTRUMENTED_JUMP_FORWARD_r22 1059 -#define _INSTRUMENTED_JUMP_FORWARD_r33 1060 -#define _INSTRUMENTED_LINE_r00 1061 -#define _INSTRUMENTED_NOT_TAKEN_r00 1062 -#define _INSTRUMENTED_NOT_TAKEN_r11 1063 -#define _INSTRUMENTED_NOT_TAKEN_r22 1064 -#define _INSTRUMENTED_NOT_TAKEN_r33 1065 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1066 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1067 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1068 -#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1069 -#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1070 -#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1071 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1072 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1073 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1074 -#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1075 -#define _IS_NONE_r11 1076 -#define _IS_OP_r03 1077 -#define _IS_OP_r13 1078 -#define _IS_OP_r23 1079 -#define _ITER_CHECK_LIST_r02 1080 -#define _ITER_CHECK_LIST_r12 1081 -#define _ITER_CHECK_LIST_r22 1082 -#define _ITER_CHECK_LIST_r33 1083 -#define _ITER_CHECK_RANGE_r02 1084 -#define _ITER_CHECK_RANGE_r12 1085 -#define _ITER_CHECK_RANGE_r22 1086 -#define _ITER_CHECK_RANGE_r33 1087 -#define _ITER_CHECK_TUPLE_r02 1088 -#define _ITER_CHECK_TUPLE_r12 1089 -#define _ITER_CHECK_TUPLE_r22 1090 -#define _ITER_CHECK_TUPLE_r33 1091 -#define _ITER_JUMP_LIST_r02 1092 -#define _ITER_JUMP_LIST_r12 1093 -#define _ITER_JUMP_LIST_r22 1094 -#define _ITER_JUMP_LIST_r33 1095 -#define _ITER_JUMP_RANGE_r02 1096 -#define _ITER_JUMP_RANGE_r12 1097 -#define _ITER_JUMP_RANGE_r22 1098 -#define _ITER_JUMP_RANGE_r33 1099 -#define _ITER_JUMP_TUPLE_r02 1100 -#define _ITER_JUMP_TUPLE_r12 1101 -#define _ITER_JUMP_TUPLE_r22 1102 -#define _ITER_JUMP_TUPLE_r33 1103 -#define _ITER_NEXT_LIST_r23 1104 -#define _ITER_NEXT_LIST_TIER_TWO_r23 1105 -#define _ITER_NEXT_RANGE_r03 1106 -#define _ITER_NEXT_RANGE_r13 1107 -#define _ITER_NEXT_RANGE_r23 1108 -#define _ITER_NEXT_TUPLE_r03 1109 -#define _ITER_NEXT_TUPLE_r13 1110 -#define _ITER_NEXT_TUPLE_r23 1111 -#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1112 -#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1113 -#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1114 -#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1115 -#define _JUMP_TO_TOP_r00 1116 -#define _LIST_APPEND_r10 1117 -#define _LIST_EXTEND_r10 1118 -#define _LOAD_ATTR_r10 1119 -#define _LOAD_ATTR_CLASS_r11 1120 -#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_r11 1121 -#define _LOAD_ATTR_INSTANCE_VALUE_r02 1122 -#define _LOAD_ATTR_INSTANCE_VALUE_r12 1123 -#define _LOAD_ATTR_INSTANCE_VALUE_r23 1124 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1125 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1126 -#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1127 -#define _LOAD_ATTR_METHOD_NO_DICT_r02 1128 -#define _LOAD_ATTR_METHOD_NO_DICT_r12 1129 -#define _LOAD_ATTR_METHOD_NO_DICT_r23 1130 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1131 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1132 -#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1133 -#define _LOAD_ATTR_MODULE_r12 1134 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1135 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1136 -#define _LOAD_ATTR_PROPERTY_FRAME_r11 1137 -#define _LOAD_ATTR_SLOT_r02 1138 -#define _LOAD_ATTR_SLOT_r12 1139 -#define _LOAD_ATTR_SLOT_r23 1140 -#define _LOAD_ATTR_WITH_HINT_r12 1141 -#define _LOAD_BUILD_CLASS_r01 1142 -#define _LOAD_BYTECODE_r00 1143 -#define _LOAD_COMMON_CONSTANT_r01 1144 -#define _LOAD_COMMON_CONSTANT_r12 1145 -#define _LOAD_COMMON_CONSTANT_r23 1146 -#define _LOAD_CONST_r01 1147 -#define _LOAD_CONST_r12 1148 -#define _LOAD_CONST_r23 1149 -#define _LOAD_CONST_INLINE_r01 1150 -#define _LOAD_CONST_INLINE_r12 1151 -#define _LOAD_CONST_INLINE_r23 1152 -#define _LOAD_CONST_INLINE_BORROW_r01 1153 -#define _LOAD_CONST_INLINE_BORROW_r12 1154 -#define _LOAD_CONST_INLINE_BORROW_r23 1155 -#define _LOAD_CONST_UNDER_INLINE_r02 1156 -#define _LOAD_CONST_UNDER_INLINE_r12 1157 -#define _LOAD_CONST_UNDER_INLINE_r23 1158 -#define _LOAD_CONST_UNDER_INLINE_BORROW_r02 1159 -#define _LOAD_CONST_UNDER_INLINE_BORROW_r12 1160 -#define _LOAD_CONST_UNDER_INLINE_BORROW_r23 1161 -#define _LOAD_DEREF_r01 1162 -#define _LOAD_FAST_r01 1163 -#define _LOAD_FAST_r12 1164 -#define _LOAD_FAST_r23 1165 -#define _LOAD_FAST_0_r01 1166 -#define _LOAD_FAST_0_r12 1167 -#define _LOAD_FAST_0_r23 1168 -#define _LOAD_FAST_1_r01 1169 -#define _LOAD_FAST_1_r12 1170 -#define _LOAD_FAST_1_r23 1171 -#define _LOAD_FAST_2_r01 1172 -#define _LOAD_FAST_2_r12 1173 -#define _LOAD_FAST_2_r23 1174 -#define _LOAD_FAST_3_r01 1175 -#define _LOAD_FAST_3_r12 1176 -#define _LOAD_FAST_3_r23 1177 -#define _LOAD_FAST_4_r01 1178 -#define _LOAD_FAST_4_r12 1179 -#define _LOAD_FAST_4_r23 1180 -#define _LOAD_FAST_5_r01 1181 -#define _LOAD_FAST_5_r12 1182 -#define _LOAD_FAST_5_r23 1183 -#define _LOAD_FAST_6_r01 1184 -#define _LOAD_FAST_6_r12 1185 -#define _LOAD_FAST_6_r23 1186 -#define _LOAD_FAST_7_r01 1187 -#define _LOAD_FAST_7_r12 1188 -#define _LOAD_FAST_7_r23 1189 -#define _LOAD_FAST_AND_CLEAR_r01 1190 -#define _LOAD_FAST_AND_CLEAR_r12 1191 -#define _LOAD_FAST_AND_CLEAR_r23 1192 -#define _LOAD_FAST_BORROW_r01 1193 -#define _LOAD_FAST_BORROW_r12 1194 -#define _LOAD_FAST_BORROW_r23 1195 -#define _LOAD_FAST_BORROW_0_r01 1196 -#define _LOAD_FAST_BORROW_0_r12 1197 -#define _LOAD_FAST_BORROW_0_r23 1198 -#define _LOAD_FAST_BORROW_1_r01 1199 -#define _LOAD_FAST_BORROW_1_r12 1200 -#define _LOAD_FAST_BORROW_1_r23 1201 -#define _LOAD_FAST_BORROW_2_r01 1202 -#define _LOAD_FAST_BORROW_2_r12 1203 -#define _LOAD_FAST_BORROW_2_r23 1204 -#define _LOAD_FAST_BORROW_3_r01 1205 -#define _LOAD_FAST_BORROW_3_r12 1206 -#define _LOAD_FAST_BORROW_3_r23 1207 -#define _LOAD_FAST_BORROW_4_r01 1208 -#define _LOAD_FAST_BORROW_4_r12 1209 -#define _LOAD_FAST_BORROW_4_r23 1210 -#define _LOAD_FAST_BORROW_5_r01 1211 -#define _LOAD_FAST_BORROW_5_r12 1212 -#define _LOAD_FAST_BORROW_5_r23 1213 -#define _LOAD_FAST_BORROW_6_r01 1214 -#define _LOAD_FAST_BORROW_6_r12 1215 -#define _LOAD_FAST_BORROW_6_r23 1216 -#define _LOAD_FAST_BORROW_7_r01 1217 -#define _LOAD_FAST_BORROW_7_r12 1218 -#define _LOAD_FAST_BORROW_7_r23 1219 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1220 -#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1221 -#define _LOAD_FAST_CHECK_r01 1222 -#define _LOAD_FAST_CHECK_r12 1223 -#define _LOAD_FAST_CHECK_r23 1224 -#define _LOAD_FAST_LOAD_FAST_r02 1225 -#define _LOAD_FAST_LOAD_FAST_r13 1226 -#define _LOAD_FROM_DICT_OR_DEREF_r11 1227 -#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1228 -#define _LOAD_GLOBAL_r00 1229 -#define _LOAD_GLOBAL_BUILTINS_r01 1230 -#define _LOAD_GLOBAL_MODULE_r01 1231 -#define _LOAD_LOCALS_r01 1232 -#define _LOAD_LOCALS_r12 1233 -#define _LOAD_LOCALS_r23 1234 -#define _LOAD_NAME_r01 1235 -#define _LOAD_SMALL_INT_r01 1236 -#define _LOAD_SMALL_INT_r12 1237 -#define _LOAD_SMALL_INT_r23 1238 -#define _LOAD_SMALL_INT_0_r01 1239 -#define _LOAD_SMALL_INT_0_r12 1240 -#define _LOAD_SMALL_INT_0_r23 1241 -#define _LOAD_SMALL_INT_1_r01 1242 -#define _LOAD_SMALL_INT_1_r12 1243 -#define _LOAD_SMALL_INT_1_r23 1244 -#define _LOAD_SMALL_INT_2_r01 1245 -#define _LOAD_SMALL_INT_2_r12 1246 -#define _LOAD_SMALL_INT_2_r23 1247 -#define _LOAD_SMALL_INT_3_r01 1248 -#define _LOAD_SMALL_INT_3_r12 1249 -#define _LOAD_SMALL_INT_3_r23 1250 -#define _LOAD_SPECIAL_r00 1251 -#define _LOAD_SUPER_ATTR_ATTR_r31 1252 -#define _LOAD_SUPER_ATTR_METHOD_r32 1253 -#define _MAKE_CALLARGS_A_TUPLE_r33 1254 -#define _MAKE_CELL_r00 1255 -#define _MAKE_FUNCTION_r11 1256 -#define _MAKE_WARM_r00 1257 -#define _MAKE_WARM_r11 1258 -#define _MAKE_WARM_r22 1259 -#define _MAKE_WARM_r33 1260 -#define _MAP_ADD_r20 1261 -#define _MATCH_CLASS_r31 1262 -#define _MATCH_KEYS_r23 1263 -#define _MATCH_MAPPING_r02 1264 -#define _MATCH_MAPPING_r12 1265 -#define _MATCH_MAPPING_r23 1266 -#define _MATCH_SEQUENCE_r02 1267 -#define _MATCH_SEQUENCE_r12 1268 -#define _MATCH_SEQUENCE_r23 1269 -#define _MAYBE_EXPAND_METHOD_r00 1270 -#define _MAYBE_EXPAND_METHOD_KW_r11 1271 -#define _MONITOR_CALL_r00 1272 -#define _MONITOR_CALL_KW_r11 1273 -#define _MONITOR_JUMP_BACKWARD_r00 1274 -#define _MONITOR_JUMP_BACKWARD_r11 1275 -#define _MONITOR_JUMP_BACKWARD_r22 1276 -#define _MONITOR_JUMP_BACKWARD_r33 1277 -#define _MONITOR_RESUME_r00 1278 -#define _NOP_r00 1279 -#define _NOP_r11 1280 -#define _NOP_r22 1281 -#define _NOP_r33 1282 -#define _POP_CALL_r20 1283 -#define _POP_CALL_LOAD_CONST_INLINE_BORROW_r21 1284 -#define _POP_CALL_ONE_r30 1285 -#define _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31 1286 -#define _POP_CALL_TWO_r30 1287 -#define _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31 1288 -#define _POP_EXCEPT_r10 1289 -#define _POP_ITER_r20 1290 -#define _POP_JUMP_IF_FALSE_r00 1291 -#define _POP_JUMP_IF_FALSE_r10 1292 -#define _POP_JUMP_IF_FALSE_r21 1293 -#define _POP_JUMP_IF_FALSE_r32 1294 -#define _POP_JUMP_IF_TRUE_r00 1295 -#define _POP_JUMP_IF_TRUE_r10 1296 -#define _POP_JUMP_IF_TRUE_r21 1297 -#define _POP_JUMP_IF_TRUE_r32 1298 -#define _POP_TOP_r10 1299 -#define _POP_TOP_FLOAT_r00 1300 -#define _POP_TOP_FLOAT_r10 1301 -#define _POP_TOP_FLOAT_r21 1302 -#define _POP_TOP_FLOAT_r32 1303 -#define _POP_TOP_INT_r00 1304 -#define _POP_TOP_INT_r10 1305 -#define _POP_TOP_INT_r21 1306 -#define _POP_TOP_INT_r32 1307 -#define _POP_TOP_LOAD_CONST_INLINE_r11 1308 -#define _POP_TOP_LOAD_CONST_INLINE_BORROW_r11 1309 -#define _POP_TOP_NOP_r00 1310 -#define _POP_TOP_NOP_r10 1311 -#define _POP_TOP_NOP_r21 1312 -#define _POP_TOP_NOP_r32 1313 -#define _POP_TOP_UNICODE_r00 1314 -#define _POP_TOP_UNICODE_r10 1315 -#define _POP_TOP_UNICODE_r21 1316 -#define _POP_TOP_UNICODE_r32 1317 -#define _POP_TWO_r20 1318 -#define _POP_TWO_LOAD_CONST_INLINE_BORROW_r21 1319 -#define _PUSH_EXC_INFO_r02 1320 -#define _PUSH_EXC_INFO_r12 1321 -#define _PUSH_EXC_INFO_r23 1322 -#define _PUSH_FRAME_r10 1323 -#define _PUSH_NULL_r01 1324 -#define _PUSH_NULL_r12 1325 -#define _PUSH_NULL_r23 1326 -#define _PUSH_NULL_CONDITIONAL_r00 1327 -#define _PY_FRAME_EX_r31 1328 -#define _PY_FRAME_GENERAL_r01 1329 -#define _PY_FRAME_KW_r11 1330 -#define _QUICKEN_RESUME_r00 1331 -#define _QUICKEN_RESUME_r11 1332 -#define _QUICKEN_RESUME_r22 1333 -#define _QUICKEN_RESUME_r33 1334 -#define _REPLACE_WITH_TRUE_r02 1335 -#define _REPLACE_WITH_TRUE_r12 1336 -#define _REPLACE_WITH_TRUE_r23 1337 -#define _RESUME_CHECK_r00 1338 -#define _RESUME_CHECK_r11 1339 -#define _RESUME_CHECK_r22 1340 -#define _RESUME_CHECK_r33 1341 -#define _RETURN_GENERATOR_r01 1342 -#define _RETURN_VALUE_r11 1343 -#define _SAVE_RETURN_OFFSET_r00 1344 -#define _SAVE_RETURN_OFFSET_r11 1345 -#define _SAVE_RETURN_OFFSET_r22 1346 -#define _SAVE_RETURN_OFFSET_r33 1347 -#define _SEND_r22 1348 -#define _SEND_GEN_FRAME_r22 1349 -#define _SETUP_ANNOTATIONS_r00 1350 -#define _SET_ADD_r10 1351 -#define _SET_FUNCTION_ATTRIBUTE_r01 1352 -#define _SET_FUNCTION_ATTRIBUTE_r11 1353 -#define _SET_FUNCTION_ATTRIBUTE_r21 1354 -#define _SET_FUNCTION_ATTRIBUTE_r32 1355 -#define _SET_IP_r00 1356 -#define _SET_IP_r11 1357 -#define _SET_IP_r22 1358 -#define _SET_IP_r33 1359 -#define _SET_UPDATE_r10 1360 -#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r02 1361 -#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12 1362 -#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22 1363 -#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32 1364 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03 1365 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13 1366 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23 1367 -#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33 1368 -#define _SPILL_OR_RELOAD_r01 1369 -#define _SPILL_OR_RELOAD_r02 1370 -#define _SPILL_OR_RELOAD_r03 1371 -#define _SPILL_OR_RELOAD_r10 1372 -#define _SPILL_OR_RELOAD_r12 1373 -#define _SPILL_OR_RELOAD_r13 1374 -#define _SPILL_OR_RELOAD_r20 1375 -#define _SPILL_OR_RELOAD_r21 1376 -#define _SPILL_OR_RELOAD_r23 1377 -#define _SPILL_OR_RELOAD_r30 1378 -#define _SPILL_OR_RELOAD_r31 1379 -#define _SPILL_OR_RELOAD_r32 1380 -#define _START_EXECUTOR_r00 1381 -#define _STORE_ATTR_r20 1382 -#define _STORE_ATTR_INSTANCE_VALUE_r21 1383 -#define _STORE_ATTR_SLOT_r21 1384 -#define _STORE_ATTR_WITH_HINT_r21 1385 -#define _STORE_DEREF_r10 1386 -#define _STORE_FAST_LOAD_FAST_r11 1387 -#define _STORE_FAST_STORE_FAST_r20 1388 -#define _STORE_GLOBAL_r10 1389 -#define _STORE_NAME_r10 1390 -#define _STORE_SLICE_r30 1391 -#define _STORE_SUBSCR_r30 1392 -#define _STORE_SUBSCR_DICT_r31 1393 -#define _STORE_SUBSCR_LIST_INT_r32 1394 -#define _SWAP_r11 1395 -#define _SWAP_2_r02 1396 -#define _SWAP_2_r12 1397 -#define _SWAP_2_r22 1398 -#define _SWAP_2_r33 1399 -#define _SWAP_3_r03 1400 -#define _SWAP_3_r13 1401 -#define _SWAP_3_r23 1402 -#define _SWAP_3_r33 1403 -#define _SWAP_FAST_r01 1404 -#define _SWAP_FAST_r11 1405 -#define _SWAP_FAST_r22 1406 -#define _SWAP_FAST_r33 1407 -#define _SWAP_FAST_0_r01 1408 -#define _SWAP_FAST_0_r11 1409 -#define _SWAP_FAST_0_r22 1410 -#define _SWAP_FAST_0_r33 1411 -#define _SWAP_FAST_1_r01 1412 -#define _SWAP_FAST_1_r11 1413 -#define _SWAP_FAST_1_r22 1414 -#define _SWAP_FAST_1_r33 1415 -#define _SWAP_FAST_2_r01 1416 -#define _SWAP_FAST_2_r11 1417 -#define _SWAP_FAST_2_r22 1418 -#define _SWAP_FAST_2_r33 1419 -#define _SWAP_FAST_3_r01 1420 -#define _SWAP_FAST_3_r11 1421 -#define _SWAP_FAST_3_r22 1422 -#define _SWAP_FAST_3_r33 1423 -#define _SWAP_FAST_4_r01 1424 -#define _SWAP_FAST_4_r11 1425 -#define _SWAP_FAST_4_r22 1426 -#define _SWAP_FAST_4_r33 1427 -#define _SWAP_FAST_5_r01 1428 -#define _SWAP_FAST_5_r11 1429 -#define _SWAP_FAST_5_r22 1430 -#define _SWAP_FAST_5_r33 1431 -#define _SWAP_FAST_6_r01 1432 -#define _SWAP_FAST_6_r11 1433 -#define _SWAP_FAST_6_r22 1434 -#define _SWAP_FAST_6_r33 1435 -#define _SWAP_FAST_7_r01 1436 -#define _SWAP_FAST_7_r11 1437 -#define _SWAP_FAST_7_r22 1438 -#define _SWAP_FAST_7_r33 1439 -#define _TIER2_RESUME_CHECK_r00 1440 -#define _TIER2_RESUME_CHECK_r11 1441 -#define _TIER2_RESUME_CHECK_r22 1442 -#define _TIER2_RESUME_CHECK_r33 1443 -#define _TO_BOOL_r11 1444 -#define _TO_BOOL_BOOL_r01 1445 -#define _TO_BOOL_BOOL_r11 1446 -#define _TO_BOOL_BOOL_r22 1447 -#define _TO_BOOL_BOOL_r33 1448 -#define _TO_BOOL_INT_r02 1449 -#define _TO_BOOL_INT_r12 1450 -#define _TO_BOOL_INT_r23 1451 -#define _TO_BOOL_LIST_r02 1452 -#define _TO_BOOL_LIST_r12 1453 -#define _TO_BOOL_LIST_r23 1454 -#define _TO_BOOL_NONE_r01 1455 -#define _TO_BOOL_NONE_r11 1456 -#define _TO_BOOL_NONE_r22 1457 -#define _TO_BOOL_NONE_r33 1458 -#define _TO_BOOL_STR_r02 1459 -#define _TO_BOOL_STR_r12 1460 -#define _TO_BOOL_STR_r23 1461 -#define _TRACE_RECORD_r00 1462 -#define _UNARY_INVERT_r12 1463 -#define _UNARY_NEGATIVE_r12 1464 -#define _UNARY_NOT_r01 1465 -#define _UNARY_NOT_r11 1466 -#define _UNARY_NOT_r22 1467 -#define _UNARY_NOT_r33 1468 -#define _UNPACK_EX_r10 1469 -#define _UNPACK_SEQUENCE_r10 1470 -#define _UNPACK_SEQUENCE_LIST_r10 1471 -#define _UNPACK_SEQUENCE_TUPLE_r10 1472 -#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1473 -#define _WITH_EXCEPT_START_r33 1474 -#define _YIELD_VALUE_r11 1475 -#define MAX_UOP_REGS_ID 1475 +#define _BINARY_OP_ADD_FLOAT_r34 598 +#define _BINARY_OP_ADD_FLOAT_r45 599 +#define _BINARY_OP_ADD_INT_r03 600 +#define _BINARY_OP_ADD_INT_r13 601 +#define _BINARY_OP_ADD_INT_r23 602 +#define _BINARY_OP_ADD_INT_r34 603 +#define _BINARY_OP_ADD_INT_r45 604 +#define _BINARY_OP_ADD_UNICODE_r03 605 +#define _BINARY_OP_ADD_UNICODE_r13 606 +#define _BINARY_OP_ADD_UNICODE_r23 607 +#define _BINARY_OP_ADD_UNICODE_r34 608 +#define _BINARY_OP_ADD_UNICODE_r45 609 +#define _BINARY_OP_EXTEND_r23 610 +#define _BINARY_OP_INPLACE_ADD_UNICODE_r21 611 +#define _BINARY_OP_MULTIPLY_FLOAT_r03 612 +#define _BINARY_OP_MULTIPLY_FLOAT_r13 613 +#define _BINARY_OP_MULTIPLY_FLOAT_r23 614 +#define _BINARY_OP_MULTIPLY_FLOAT_r34 615 +#define _BINARY_OP_MULTIPLY_FLOAT_r45 616 +#define _BINARY_OP_MULTIPLY_INT_r03 617 +#define _BINARY_OP_MULTIPLY_INT_r13 618 +#define _BINARY_OP_MULTIPLY_INT_r23 619 +#define _BINARY_OP_MULTIPLY_INT_r34 620 +#define _BINARY_OP_MULTIPLY_INT_r45 621 +#define _BINARY_OP_SUBSCR_CHECK_FUNC_r23 622 +#define _BINARY_OP_SUBSCR_DICT_r23 623 +#define _BINARY_OP_SUBSCR_INIT_CALL_r01 624 +#define _BINARY_OP_SUBSCR_INIT_CALL_r11 625 +#define _BINARY_OP_SUBSCR_INIT_CALL_r21 626 +#define _BINARY_OP_SUBSCR_INIT_CALL_r31 627 +#define _BINARY_OP_SUBSCR_INIT_CALL_r42 628 +#define _BINARY_OP_SUBSCR_INIT_CALL_r53 629 +#define _BINARY_OP_SUBSCR_LIST_INT_r23 630 +#define _BINARY_OP_SUBSCR_LIST_SLICE_r23 631 +#define _BINARY_OP_SUBSCR_STR_INT_r23 632 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r03 633 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r13 634 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r23 635 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r34 636 +#define _BINARY_OP_SUBSCR_TUPLE_INT_r45 637 +#define _BINARY_OP_SUBSCR_USTR_INT_r23 638 +#define _BINARY_OP_SUBTRACT_FLOAT_r03 639 +#define _BINARY_OP_SUBTRACT_FLOAT_r13 640 +#define _BINARY_OP_SUBTRACT_FLOAT_r23 641 +#define _BINARY_OP_SUBTRACT_FLOAT_r34 642 +#define _BINARY_OP_SUBTRACT_FLOAT_r45 643 +#define _BINARY_OP_SUBTRACT_INT_r03 644 +#define _BINARY_OP_SUBTRACT_INT_r13 645 +#define _BINARY_OP_SUBTRACT_INT_r23 646 +#define _BINARY_OP_SUBTRACT_INT_r34 647 +#define _BINARY_OP_SUBTRACT_INT_r45 648 +#define _BINARY_SLICE_r31 649 +#define _BUILD_INTERPOLATION_r01 650 +#define _BUILD_LIST_r01 651 +#define _BUILD_MAP_r01 652 +#define _BUILD_SET_r01 653 +#define _BUILD_SLICE_r01 654 +#define _BUILD_STRING_r01 655 +#define _BUILD_TEMPLATE_r21 656 +#define _BUILD_TUPLE_r01 657 +#define _CALL_BUILTIN_CLASS_r01 658 +#define _CALL_BUILTIN_FAST_r01 659 +#define _CALL_BUILTIN_FAST_WITH_KEYWORDS_r01 660 +#define _CALL_BUILTIN_O_r03 661 +#define _CALL_FUNCTION_EX_NON_PY_GENERAL_r41 662 +#define _CALL_INTRINSIC_1_r11 663 +#define _CALL_INTRINSIC_2_r21 664 +#define _CALL_ISINSTANCE_r41 665 +#define _CALL_KW_NON_PY_r11 666 +#define _CALL_LEN_r33 667 +#define _CALL_LIST_APPEND_r03 668 +#define _CALL_LIST_APPEND_r13 669 +#define _CALL_LIST_APPEND_r23 670 +#define _CALL_LIST_APPEND_r33 671 +#define _CALL_LIST_APPEND_r44 672 +#define _CALL_LIST_APPEND_r55 673 +#define _CALL_METHOD_DESCRIPTOR_FAST_r01 674 +#define _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01 675 +#define _CALL_METHOD_DESCRIPTOR_NOARGS_r01 676 +#define _CALL_METHOD_DESCRIPTOR_O_r04 677 +#define _CALL_NON_PY_GENERAL_r01 678 +#define _CALL_STR_1_r32 679 +#define _CALL_TUPLE_1_r32 680 +#define _CALL_TYPE_1_r02 681 +#define _CALL_TYPE_1_r12 682 +#define _CALL_TYPE_1_r22 683 +#define _CALL_TYPE_1_r32 684 +#define _CALL_TYPE_1_r43 685 +#define _CALL_TYPE_1_r54 686 +#define _CHECK_AND_ALLOCATE_OBJECT_r00 687 +#define _CHECK_ATTR_CLASS_r01 688 +#define _CHECK_ATTR_CLASS_r11 689 +#define _CHECK_ATTR_CLASS_r22 690 +#define _CHECK_ATTR_CLASS_r33 691 +#define _CHECK_ATTR_CLASS_r44 692 +#define _CHECK_ATTR_CLASS_r55 693 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r01 694 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r11 695 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r22 696 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r33 697 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r44 698 +#define _CHECK_ATTR_METHOD_LAZY_DICT_r55 699 +#define _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 700 +#define _CHECK_EG_MATCH_r22 701 +#define _CHECK_EXC_MATCH_r22 702 +#define _CHECK_FUNCTION_EXACT_ARGS_r00 703 +#define _CHECK_FUNCTION_VERSION_r00 704 +#define _CHECK_FUNCTION_VERSION_INLINE_r00 705 +#define _CHECK_FUNCTION_VERSION_INLINE_r11 706 +#define _CHECK_FUNCTION_VERSION_INLINE_r22 707 +#define _CHECK_FUNCTION_VERSION_INLINE_r33 708 +#define _CHECK_FUNCTION_VERSION_INLINE_r44 709 +#define _CHECK_FUNCTION_VERSION_INLINE_r55 710 +#define _CHECK_FUNCTION_VERSION_KW_r11 711 +#define _CHECK_IS_NOT_PY_CALLABLE_r00 712 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r04 713 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r14 714 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r24 715 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r34 716 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r44 717 +#define _CHECK_IS_NOT_PY_CALLABLE_EX_r55 718 +#define _CHECK_IS_NOT_PY_CALLABLE_KW_r11 719 +#define _CHECK_IS_PY_CALLABLE_EX_r04 720 +#define _CHECK_IS_PY_CALLABLE_EX_r14 721 +#define _CHECK_IS_PY_CALLABLE_EX_r24 722 +#define _CHECK_IS_PY_CALLABLE_EX_r34 723 +#define _CHECK_IS_PY_CALLABLE_EX_r44 724 +#define _CHECK_IS_PY_CALLABLE_EX_r55 725 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 726 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 727 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 728 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 729 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r44 730 +#define _CHECK_MANAGED_OBJECT_HAS_VALUES_r55 731 +#define _CHECK_METHOD_VERSION_r00 732 +#define _CHECK_METHOD_VERSION_KW_r11 733 +#define _CHECK_PEP_523_r00 734 +#define _CHECK_PEP_523_r11 735 +#define _CHECK_PEP_523_r22 736 +#define _CHECK_PEP_523_r33 737 +#define _CHECK_PEP_523_r44 738 +#define _CHECK_PEP_523_r55 739 +#define _CHECK_PERIODIC_r00 740 +#define _CHECK_PERIODIC_AT_END_r00 741 +#define _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 742 +#define _CHECK_RECURSION_REMAINING_r00 743 +#define _CHECK_RECURSION_REMAINING_r11 744 +#define _CHECK_RECURSION_REMAINING_r22 745 +#define _CHECK_RECURSION_REMAINING_r33 746 +#define _CHECK_RECURSION_REMAINING_r44 747 +#define _CHECK_RECURSION_REMAINING_r55 748 +#define _CHECK_STACK_SPACE_r00 749 +#define _CHECK_STACK_SPACE_OPERAND_r00 750 +#define _CHECK_STACK_SPACE_OPERAND_r11 751 +#define _CHECK_STACK_SPACE_OPERAND_r22 752 +#define _CHECK_STACK_SPACE_OPERAND_r33 753 +#define _CHECK_STACK_SPACE_OPERAND_r44 754 +#define _CHECK_STACK_SPACE_OPERAND_r55 755 +#define _CHECK_VALIDITY_r00 756 +#define _CHECK_VALIDITY_r11 757 +#define _CHECK_VALIDITY_r22 758 +#define _CHECK_VALIDITY_r33 759 +#define _CHECK_VALIDITY_r44 760 +#define _CHECK_VALIDITY_r55 761 +#define _COLD_DYNAMIC_EXIT_r00 762 +#define _COLD_EXIT_r00 763 +#define _COMPARE_OP_r21 764 +#define _COMPARE_OP_FLOAT_r03 765 +#define _COMPARE_OP_FLOAT_r13 766 +#define _COMPARE_OP_FLOAT_r23 767 +#define _COMPARE_OP_FLOAT_r34 768 +#define _COMPARE_OP_FLOAT_r45 769 +#define _COMPARE_OP_INT_r23 770 +#define _COMPARE_OP_STR_r23 771 +#define _CONTAINS_OP_r23 772 +#define _CONTAINS_OP_DICT_r23 773 +#define _CONTAINS_OP_SET_r23 774 +#define _CONVERT_VALUE_r11 775 +#define _COPY_r01 776 +#define _COPY_1_r02 777 +#define _COPY_1_r12 778 +#define _COPY_1_r23 779 +#define _COPY_1_r34 780 +#define _COPY_1_r45 781 +#define _COPY_2_r03 782 +#define _COPY_2_r13 783 +#define _COPY_2_r23 784 +#define _COPY_2_r34 785 +#define _COPY_2_r45 786 +#define _COPY_3_r04 787 +#define _COPY_3_r14 788 +#define _COPY_3_r24 789 +#define _COPY_3_r34 790 +#define _COPY_3_r45 791 +#define _COPY_FREE_VARS_r00 792 +#define _COPY_FREE_VARS_r11 793 +#define _COPY_FREE_VARS_r22 794 +#define _COPY_FREE_VARS_r33 795 +#define _COPY_FREE_VARS_r44 796 +#define _COPY_FREE_VARS_r55 797 +#define _CREATE_INIT_FRAME_r01 798 +#define _DELETE_ATTR_r10 799 +#define _DELETE_DEREF_r00 800 +#define _DELETE_FAST_r00 801 +#define _DELETE_GLOBAL_r00 802 +#define _DELETE_NAME_r00 803 +#define _DELETE_SUBSCR_r20 804 +#define _DEOPT_r00 805 +#define _DEOPT_r10 806 +#define _DEOPT_r20 807 +#define _DEOPT_r30 808 +#define _DEOPT_r40 809 +#define _DEOPT_r50 810 +#define _DICT_MERGE_r10 811 +#define _DICT_UPDATE_r10 812 +#define _DO_CALL_r01 813 +#define _DO_CALL_FUNCTION_EX_r41 814 +#define _DO_CALL_KW_r11 815 +#define _DYNAMIC_EXIT_r00 816 +#define _DYNAMIC_EXIT_r10 817 +#define _DYNAMIC_EXIT_r20 818 +#define _DYNAMIC_EXIT_r30 819 +#define _DYNAMIC_EXIT_r40 820 +#define _DYNAMIC_EXIT_r50 821 +#define _END_FOR_r10 822 +#define _END_SEND_r21 823 +#define _ERROR_POP_N_r00 824 +#define _EXIT_INIT_CHECK_r10 825 +#define _EXIT_TRACE_r00 826 +#define _EXIT_TRACE_r10 827 +#define _EXIT_TRACE_r20 828 +#define _EXIT_TRACE_r30 829 +#define _EXIT_TRACE_r40 830 +#define _EXIT_TRACE_r50 831 +#define _EXPAND_METHOD_r00 832 +#define _EXPAND_METHOD_KW_r11 833 +#define _FATAL_ERROR_r00 834 +#define _FATAL_ERROR_r11 835 +#define _FATAL_ERROR_r22 836 +#define _FATAL_ERROR_r33 837 +#define _FATAL_ERROR_r44 838 +#define _FATAL_ERROR_r55 839 +#define _FORMAT_SIMPLE_r11 840 +#define _FORMAT_WITH_SPEC_r21 841 +#define _FOR_ITER_r23 842 +#define _FOR_ITER_GEN_FRAME_r03 843 +#define _FOR_ITER_GEN_FRAME_r13 844 +#define _FOR_ITER_GEN_FRAME_r23 845 +#define _FOR_ITER_GEN_FRAME_r34 846 +#define _FOR_ITER_GEN_FRAME_r45 847 +#define _FOR_ITER_TIER_TWO_r23 848 +#define _GET_AITER_r11 849 +#define _GET_ANEXT_r12 850 +#define _GET_AWAITABLE_r11 851 +#define _GET_ITER_r12 852 +#define _GET_LEN_r12 853 +#define _GET_YIELD_FROM_ITER_r11 854 +#define _GUARD_BINARY_OP_EXTEND_r22 855 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02 856 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12 857 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22 858 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33 859 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r44 860 +#define _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r55 861 +#define _GUARD_BIT_IS_SET_POP_r00 862 +#define _GUARD_BIT_IS_SET_POP_r10 863 +#define _GUARD_BIT_IS_SET_POP_r21 864 +#define _GUARD_BIT_IS_SET_POP_r32 865 +#define _GUARD_BIT_IS_SET_POP_r43 866 +#define _GUARD_BIT_IS_SET_POP_r54 867 +#define _GUARD_BIT_IS_SET_POP_4_r00 868 +#define _GUARD_BIT_IS_SET_POP_4_r10 869 +#define _GUARD_BIT_IS_SET_POP_4_r21 870 +#define _GUARD_BIT_IS_SET_POP_4_r32 871 +#define _GUARD_BIT_IS_SET_POP_4_r43 872 +#define _GUARD_BIT_IS_SET_POP_4_r54 873 +#define _GUARD_BIT_IS_SET_POP_5_r00 874 +#define _GUARD_BIT_IS_SET_POP_5_r10 875 +#define _GUARD_BIT_IS_SET_POP_5_r21 876 +#define _GUARD_BIT_IS_SET_POP_5_r32 877 +#define _GUARD_BIT_IS_SET_POP_5_r43 878 +#define _GUARD_BIT_IS_SET_POP_5_r54 879 +#define _GUARD_BIT_IS_SET_POP_6_r00 880 +#define _GUARD_BIT_IS_SET_POP_6_r10 881 +#define _GUARD_BIT_IS_SET_POP_6_r21 882 +#define _GUARD_BIT_IS_SET_POP_6_r32 883 +#define _GUARD_BIT_IS_SET_POP_6_r43 884 +#define _GUARD_BIT_IS_SET_POP_6_r54 885 +#define _GUARD_BIT_IS_SET_POP_7_r00 886 +#define _GUARD_BIT_IS_SET_POP_7_r10 887 +#define _GUARD_BIT_IS_SET_POP_7_r21 888 +#define _GUARD_BIT_IS_SET_POP_7_r32 889 +#define _GUARD_BIT_IS_SET_POP_7_r43 890 +#define _GUARD_BIT_IS_SET_POP_7_r54 891 +#define _GUARD_BIT_IS_UNSET_POP_r00 892 +#define _GUARD_BIT_IS_UNSET_POP_r10 893 +#define _GUARD_BIT_IS_UNSET_POP_r21 894 +#define _GUARD_BIT_IS_UNSET_POP_r32 895 +#define _GUARD_BIT_IS_UNSET_POP_r43 896 +#define _GUARD_BIT_IS_UNSET_POP_r54 897 +#define _GUARD_BIT_IS_UNSET_POP_4_r00 898 +#define _GUARD_BIT_IS_UNSET_POP_4_r10 899 +#define _GUARD_BIT_IS_UNSET_POP_4_r21 900 +#define _GUARD_BIT_IS_UNSET_POP_4_r32 901 +#define _GUARD_BIT_IS_UNSET_POP_4_r43 902 +#define _GUARD_BIT_IS_UNSET_POP_4_r54 903 +#define _GUARD_BIT_IS_UNSET_POP_5_r00 904 +#define _GUARD_BIT_IS_UNSET_POP_5_r10 905 +#define _GUARD_BIT_IS_UNSET_POP_5_r21 906 +#define _GUARD_BIT_IS_UNSET_POP_5_r32 907 +#define _GUARD_BIT_IS_UNSET_POP_5_r43 908 +#define _GUARD_BIT_IS_UNSET_POP_5_r54 909 +#define _GUARD_BIT_IS_UNSET_POP_6_r00 910 +#define _GUARD_BIT_IS_UNSET_POP_6_r10 911 +#define _GUARD_BIT_IS_UNSET_POP_6_r21 912 +#define _GUARD_BIT_IS_UNSET_POP_6_r32 913 +#define _GUARD_BIT_IS_UNSET_POP_6_r43 914 +#define _GUARD_BIT_IS_UNSET_POP_6_r54 915 +#define _GUARD_BIT_IS_UNSET_POP_7_r00 916 +#define _GUARD_BIT_IS_UNSET_POP_7_r10 917 +#define _GUARD_BIT_IS_UNSET_POP_7_r21 918 +#define _GUARD_BIT_IS_UNSET_POP_7_r32 919 +#define _GUARD_BIT_IS_UNSET_POP_7_r43 920 +#define _GUARD_BIT_IS_UNSET_POP_7_r54 921 +#define _GUARD_CALLABLE_ISINSTANCE_r04 922 +#define _GUARD_CALLABLE_ISINSTANCE_r14 923 +#define _GUARD_CALLABLE_ISINSTANCE_r24 924 +#define _GUARD_CALLABLE_ISINSTANCE_r34 925 +#define _GUARD_CALLABLE_ISINSTANCE_r44 926 +#define _GUARD_CALLABLE_ISINSTANCE_r55 927 +#define _GUARD_CALLABLE_LEN_r03 928 +#define _GUARD_CALLABLE_LEN_r13 929 +#define _GUARD_CALLABLE_LEN_r23 930 +#define _GUARD_CALLABLE_LEN_r33 931 +#define _GUARD_CALLABLE_LEN_r44 932 +#define _GUARD_CALLABLE_LEN_r55 933 +#define _GUARD_CALLABLE_LIST_APPEND_r03 934 +#define _GUARD_CALLABLE_LIST_APPEND_r13 935 +#define _GUARD_CALLABLE_LIST_APPEND_r23 936 +#define _GUARD_CALLABLE_LIST_APPEND_r33 937 +#define _GUARD_CALLABLE_LIST_APPEND_r44 938 +#define _GUARD_CALLABLE_LIST_APPEND_r55 939 +#define _GUARD_CALLABLE_STR_1_r03 940 +#define _GUARD_CALLABLE_STR_1_r13 941 +#define _GUARD_CALLABLE_STR_1_r23 942 +#define _GUARD_CALLABLE_STR_1_r33 943 +#define _GUARD_CALLABLE_STR_1_r44 944 +#define _GUARD_CALLABLE_STR_1_r55 945 +#define _GUARD_CALLABLE_TUPLE_1_r03 946 +#define _GUARD_CALLABLE_TUPLE_1_r13 947 +#define _GUARD_CALLABLE_TUPLE_1_r23 948 +#define _GUARD_CALLABLE_TUPLE_1_r33 949 +#define _GUARD_CALLABLE_TUPLE_1_r44 950 +#define _GUARD_CALLABLE_TUPLE_1_r55 951 +#define _GUARD_CALLABLE_TYPE_1_r03 952 +#define _GUARD_CALLABLE_TYPE_1_r13 953 +#define _GUARD_CALLABLE_TYPE_1_r23 954 +#define _GUARD_CALLABLE_TYPE_1_r33 955 +#define _GUARD_CALLABLE_TYPE_1_r44 956 +#define _GUARD_CALLABLE_TYPE_1_r55 957 +#define _GUARD_CODE_VERSION_r00 958 +#define _GUARD_CODE_VERSION_r11 959 +#define _GUARD_CODE_VERSION_r22 960 +#define _GUARD_CODE_VERSION_r33 961 +#define _GUARD_CODE_VERSION_r44 962 +#define _GUARD_CODE_VERSION_r55 963 +#define _GUARD_DORV_NO_DICT_r01 964 +#define _GUARD_DORV_NO_DICT_r11 965 +#define _GUARD_DORV_NO_DICT_r22 966 +#define _GUARD_DORV_NO_DICT_r33 967 +#define _GUARD_DORV_NO_DICT_r44 968 +#define _GUARD_DORV_NO_DICT_r55 969 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 970 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 971 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 972 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 973 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r44 974 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r55 975 +#define _GUARD_GLOBALS_VERSION_r00 976 +#define _GUARD_GLOBALS_VERSION_r11 977 +#define _GUARD_GLOBALS_VERSION_r22 978 +#define _GUARD_GLOBALS_VERSION_r33 979 +#define _GUARD_GLOBALS_VERSION_r44 980 +#define _GUARD_GLOBALS_VERSION_r55 981 +#define _GUARD_IP_RETURN_GENERATOR_r00 982 +#define _GUARD_IP_RETURN_GENERATOR_r11 983 +#define _GUARD_IP_RETURN_GENERATOR_r22 984 +#define _GUARD_IP_RETURN_GENERATOR_r33 985 +#define _GUARD_IP_RETURN_GENERATOR_r44 986 +#define _GUARD_IP_RETURN_GENERATOR_r55 987 +#define _GUARD_IP_RETURN_VALUE_r00 988 +#define _GUARD_IP_RETURN_VALUE_r11 989 +#define _GUARD_IP_RETURN_VALUE_r22 990 +#define _GUARD_IP_RETURN_VALUE_r33 991 +#define _GUARD_IP_RETURN_VALUE_r44 992 +#define _GUARD_IP_RETURN_VALUE_r55 993 +#define _GUARD_IP_YIELD_VALUE_r00 994 +#define _GUARD_IP_YIELD_VALUE_r11 995 +#define _GUARD_IP_YIELD_VALUE_r22 996 +#define _GUARD_IP_YIELD_VALUE_r33 997 +#define _GUARD_IP_YIELD_VALUE_r44 998 +#define _GUARD_IP_YIELD_VALUE_r55 999 +#define _GUARD_IP__PUSH_FRAME_r00 1000 +#define _GUARD_IP__PUSH_FRAME_r11 1001 +#define _GUARD_IP__PUSH_FRAME_r22 1002 +#define _GUARD_IP__PUSH_FRAME_r33 1003 +#define _GUARD_IP__PUSH_FRAME_r44 1004 +#define _GUARD_IP__PUSH_FRAME_r55 1005 +#define _GUARD_IS_FALSE_POP_r00 1006 +#define _GUARD_IS_FALSE_POP_r10 1007 +#define _GUARD_IS_FALSE_POP_r21 1008 +#define _GUARD_IS_FALSE_POP_r32 1009 +#define _GUARD_IS_FALSE_POP_r43 1010 +#define _GUARD_IS_FALSE_POP_r54 1011 +#define _GUARD_IS_NONE_POP_r00 1012 +#define _GUARD_IS_NONE_POP_r10 1013 +#define _GUARD_IS_NONE_POP_r21 1014 +#define _GUARD_IS_NONE_POP_r32 1015 +#define _GUARD_IS_NONE_POP_r43 1016 +#define _GUARD_IS_NONE_POP_r54 1017 +#define _GUARD_IS_NOT_NONE_POP_r10 1018 +#define _GUARD_IS_TRUE_POP_r00 1019 +#define _GUARD_IS_TRUE_POP_r10 1020 +#define _GUARD_IS_TRUE_POP_r21 1021 +#define _GUARD_IS_TRUE_POP_r32 1022 +#define _GUARD_IS_TRUE_POP_r43 1023 +#define _GUARD_IS_TRUE_POP_r54 1024 +#define _GUARD_KEYS_VERSION_r01 1025 +#define _GUARD_KEYS_VERSION_r11 1026 +#define _GUARD_KEYS_VERSION_r22 1027 +#define _GUARD_KEYS_VERSION_r33 1028 +#define _GUARD_KEYS_VERSION_r44 1029 +#define _GUARD_KEYS_VERSION_r55 1030 +#define _GUARD_NOS_ANY_DICT_r02 1031 +#define _GUARD_NOS_ANY_DICT_r12 1032 +#define _GUARD_NOS_ANY_DICT_r22 1033 +#define _GUARD_NOS_ANY_DICT_r33 1034 +#define _GUARD_NOS_ANY_DICT_r44 1035 +#define _GUARD_NOS_ANY_DICT_r55 1036 +#define _GUARD_NOS_COMPACT_ASCII_r02 1037 +#define _GUARD_NOS_COMPACT_ASCII_r12 1038 +#define _GUARD_NOS_COMPACT_ASCII_r22 1039 +#define _GUARD_NOS_COMPACT_ASCII_r33 1040 +#define _GUARD_NOS_COMPACT_ASCII_r44 1041 +#define _GUARD_NOS_COMPACT_ASCII_r55 1042 +#define _GUARD_NOS_DICT_r02 1043 +#define _GUARD_NOS_DICT_r12 1044 +#define _GUARD_NOS_DICT_r22 1045 +#define _GUARD_NOS_DICT_r33 1046 +#define _GUARD_NOS_DICT_r44 1047 +#define _GUARD_NOS_DICT_r55 1048 +#define _GUARD_NOS_FLOAT_r02 1049 +#define _GUARD_NOS_FLOAT_r12 1050 +#define _GUARD_NOS_FLOAT_r22 1051 +#define _GUARD_NOS_FLOAT_r33 1052 +#define _GUARD_NOS_FLOAT_r44 1053 +#define _GUARD_NOS_FLOAT_r55 1054 +#define _GUARD_NOS_INT_r02 1055 +#define _GUARD_NOS_INT_r12 1056 +#define _GUARD_NOS_INT_r22 1057 +#define _GUARD_NOS_INT_r33 1058 +#define _GUARD_NOS_INT_r44 1059 +#define _GUARD_NOS_INT_r55 1060 +#define _GUARD_NOS_LIST_r02 1061 +#define _GUARD_NOS_LIST_r12 1062 +#define _GUARD_NOS_LIST_r22 1063 +#define _GUARD_NOS_LIST_r33 1064 +#define _GUARD_NOS_LIST_r44 1065 +#define _GUARD_NOS_LIST_r55 1066 +#define _GUARD_NOS_NOT_NULL_r02 1067 +#define _GUARD_NOS_NOT_NULL_r12 1068 +#define _GUARD_NOS_NOT_NULL_r22 1069 +#define _GUARD_NOS_NOT_NULL_r33 1070 +#define _GUARD_NOS_NOT_NULL_r44 1071 +#define _GUARD_NOS_NOT_NULL_r55 1072 +#define _GUARD_NOS_NULL_r02 1073 +#define _GUARD_NOS_NULL_r12 1074 +#define _GUARD_NOS_NULL_r22 1075 +#define _GUARD_NOS_NULL_r33 1076 +#define _GUARD_NOS_NULL_r44 1077 +#define _GUARD_NOS_NULL_r55 1078 +#define _GUARD_NOS_OVERFLOWED_r02 1079 +#define _GUARD_NOS_OVERFLOWED_r12 1080 +#define _GUARD_NOS_OVERFLOWED_r22 1081 +#define _GUARD_NOS_OVERFLOWED_r33 1082 +#define _GUARD_NOS_OVERFLOWED_r44 1083 +#define _GUARD_NOS_OVERFLOWED_r55 1084 +#define _GUARD_NOS_TUPLE_r02 1085 +#define _GUARD_NOS_TUPLE_r12 1086 +#define _GUARD_NOS_TUPLE_r22 1087 +#define _GUARD_NOS_TUPLE_r33 1088 +#define _GUARD_NOS_TUPLE_r44 1089 +#define _GUARD_NOS_TUPLE_r55 1090 +#define _GUARD_NOS_UNICODE_r02 1091 +#define _GUARD_NOS_UNICODE_r12 1092 +#define _GUARD_NOS_UNICODE_r22 1093 +#define _GUARD_NOS_UNICODE_r33 1094 +#define _GUARD_NOS_UNICODE_r44 1095 +#define _GUARD_NOS_UNICODE_r55 1096 +#define _GUARD_NOT_EXHAUSTED_LIST_r02 1097 +#define _GUARD_NOT_EXHAUSTED_LIST_r12 1098 +#define _GUARD_NOT_EXHAUSTED_LIST_r22 1099 +#define _GUARD_NOT_EXHAUSTED_LIST_r33 1100 +#define _GUARD_NOT_EXHAUSTED_LIST_r44 1101 +#define _GUARD_NOT_EXHAUSTED_LIST_r55 1102 +#define _GUARD_NOT_EXHAUSTED_RANGE_r02 1103 +#define _GUARD_NOT_EXHAUSTED_RANGE_r12 1104 +#define _GUARD_NOT_EXHAUSTED_RANGE_r22 1105 +#define _GUARD_NOT_EXHAUSTED_RANGE_r33 1106 +#define _GUARD_NOT_EXHAUSTED_RANGE_r44 1107 +#define _GUARD_NOT_EXHAUSTED_RANGE_r55 1108 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r02 1109 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r12 1110 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r22 1111 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r33 1112 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r44 1113 +#define _GUARD_NOT_EXHAUSTED_TUPLE_r55 1114 +#define _GUARD_THIRD_NULL_r03 1115 +#define _GUARD_THIRD_NULL_r13 1116 +#define _GUARD_THIRD_NULL_r23 1117 +#define _GUARD_THIRD_NULL_r33 1118 +#define _GUARD_THIRD_NULL_r44 1119 +#define _GUARD_THIRD_NULL_r55 1120 +#define _GUARD_TOS_ANY_DICT_r01 1121 +#define _GUARD_TOS_ANY_DICT_r11 1122 +#define _GUARD_TOS_ANY_DICT_r22 1123 +#define _GUARD_TOS_ANY_DICT_r33 1124 +#define _GUARD_TOS_ANY_DICT_r44 1125 +#define _GUARD_TOS_ANY_DICT_r55 1126 +#define _GUARD_TOS_ANY_SET_r01 1127 +#define _GUARD_TOS_ANY_SET_r11 1128 +#define _GUARD_TOS_ANY_SET_r22 1129 +#define _GUARD_TOS_ANY_SET_r33 1130 +#define _GUARD_TOS_ANY_SET_r44 1131 +#define _GUARD_TOS_ANY_SET_r55 1132 +#define _GUARD_TOS_DICT_r01 1133 +#define _GUARD_TOS_DICT_r11 1134 +#define _GUARD_TOS_DICT_r22 1135 +#define _GUARD_TOS_DICT_r33 1136 +#define _GUARD_TOS_DICT_r44 1137 +#define _GUARD_TOS_DICT_r55 1138 +#define _GUARD_TOS_FLOAT_r01 1139 +#define _GUARD_TOS_FLOAT_r11 1140 +#define _GUARD_TOS_FLOAT_r22 1141 +#define _GUARD_TOS_FLOAT_r33 1142 +#define _GUARD_TOS_FLOAT_r44 1143 +#define _GUARD_TOS_FLOAT_r55 1144 +#define _GUARD_TOS_FROZENDICT_r01 1145 +#define _GUARD_TOS_FROZENDICT_r11 1146 +#define _GUARD_TOS_FROZENDICT_r22 1147 +#define _GUARD_TOS_FROZENDICT_r33 1148 +#define _GUARD_TOS_FROZENDICT_r44 1149 +#define _GUARD_TOS_FROZENDICT_r55 1150 +#define _GUARD_TOS_FROZENSET_r01 1151 +#define _GUARD_TOS_FROZENSET_r11 1152 +#define _GUARD_TOS_FROZENSET_r22 1153 +#define _GUARD_TOS_FROZENSET_r33 1154 +#define _GUARD_TOS_FROZENSET_r44 1155 +#define _GUARD_TOS_FROZENSET_r55 1156 +#define _GUARD_TOS_INT_r01 1157 +#define _GUARD_TOS_INT_r11 1158 +#define _GUARD_TOS_INT_r22 1159 +#define _GUARD_TOS_INT_r33 1160 +#define _GUARD_TOS_INT_r44 1161 +#define _GUARD_TOS_INT_r55 1162 +#define _GUARD_TOS_LIST_r01 1163 +#define _GUARD_TOS_LIST_r11 1164 +#define _GUARD_TOS_LIST_r22 1165 +#define _GUARD_TOS_LIST_r33 1166 +#define _GUARD_TOS_LIST_r44 1167 +#define _GUARD_TOS_LIST_r55 1168 +#define _GUARD_TOS_OVERFLOWED_r01 1169 +#define _GUARD_TOS_OVERFLOWED_r11 1170 +#define _GUARD_TOS_OVERFLOWED_r22 1171 +#define _GUARD_TOS_OVERFLOWED_r33 1172 +#define _GUARD_TOS_OVERFLOWED_r44 1173 +#define _GUARD_TOS_OVERFLOWED_r55 1174 +#define _GUARD_TOS_SET_r01 1175 +#define _GUARD_TOS_SET_r11 1176 +#define _GUARD_TOS_SET_r22 1177 +#define _GUARD_TOS_SET_r33 1178 +#define _GUARD_TOS_SET_r44 1179 +#define _GUARD_TOS_SET_r55 1180 +#define _GUARD_TOS_SLICE_r01 1181 +#define _GUARD_TOS_SLICE_r11 1182 +#define _GUARD_TOS_SLICE_r22 1183 +#define _GUARD_TOS_SLICE_r33 1184 +#define _GUARD_TOS_SLICE_r44 1185 +#define _GUARD_TOS_SLICE_r55 1186 +#define _GUARD_TOS_TUPLE_r01 1187 +#define _GUARD_TOS_TUPLE_r11 1188 +#define _GUARD_TOS_TUPLE_r22 1189 +#define _GUARD_TOS_TUPLE_r33 1190 +#define _GUARD_TOS_TUPLE_r44 1191 +#define _GUARD_TOS_TUPLE_r55 1192 +#define _GUARD_TOS_UNICODE_r01 1193 +#define _GUARD_TOS_UNICODE_r11 1194 +#define _GUARD_TOS_UNICODE_r22 1195 +#define _GUARD_TOS_UNICODE_r33 1196 +#define _GUARD_TOS_UNICODE_r44 1197 +#define _GUARD_TOS_UNICODE_r55 1198 +#define _GUARD_TYPE_VERSION_r01 1199 +#define _GUARD_TYPE_VERSION_r11 1200 +#define _GUARD_TYPE_VERSION_r22 1201 +#define _GUARD_TYPE_VERSION_r33 1202 +#define _GUARD_TYPE_VERSION_r44 1203 +#define _GUARD_TYPE_VERSION_r55 1204 +#define _GUARD_TYPE_VERSION_AND_LOCK_r01 1205 +#define _GUARD_TYPE_VERSION_AND_LOCK_r11 1206 +#define _GUARD_TYPE_VERSION_AND_LOCK_r22 1207 +#define _GUARD_TYPE_VERSION_AND_LOCK_r33 1208 +#define _GUARD_TYPE_VERSION_AND_LOCK_r44 1209 +#define _GUARD_TYPE_VERSION_AND_LOCK_r55 1210 +#define _HANDLE_PENDING_AND_DEOPT_r00 1211 +#define _HANDLE_PENDING_AND_DEOPT_r10 1212 +#define _HANDLE_PENDING_AND_DEOPT_r20 1213 +#define _HANDLE_PENDING_AND_DEOPT_r30 1214 +#define _HANDLE_PENDING_AND_DEOPT_r40 1215 +#define _HANDLE_PENDING_AND_DEOPT_r50 1216 +#define _IMPORT_FROM_r12 1217 +#define _IMPORT_NAME_r21 1218 +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 1219 +#define _INIT_CALL_PY_EXACT_ARGS_r01 1220 +#define _INIT_CALL_PY_EXACT_ARGS_0_r01 1221 +#define _INIT_CALL_PY_EXACT_ARGS_1_r01 1222 +#define _INIT_CALL_PY_EXACT_ARGS_2_r01 1223 +#define _INIT_CALL_PY_EXACT_ARGS_3_r01 1224 +#define _INIT_CALL_PY_EXACT_ARGS_4_r01 1225 +#define _INSERT_1_LOAD_CONST_INLINE_r02 1226 +#define _INSERT_1_LOAD_CONST_INLINE_r12 1227 +#define _INSERT_1_LOAD_CONST_INLINE_r23 1228 +#define _INSERT_1_LOAD_CONST_INLINE_r34 1229 +#define _INSERT_1_LOAD_CONST_INLINE_r45 1230 +#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r02 1231 +#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r12 1232 +#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r23 1233 +#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r34 1234 +#define _INSERT_1_LOAD_CONST_INLINE_BORROW_r45 1235 +#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r03 1236 +#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r13 1237 +#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r23 1238 +#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r34 1239 +#define _INSERT_2_LOAD_CONST_INLINE_BORROW_r45 1240 +#define _INSERT_NULL_r10 1241 +#define _INSTRUMENTED_FOR_ITER_r23 1242 +#define _INSTRUMENTED_INSTRUCTION_r00 1243 +#define _INSTRUMENTED_JUMP_FORWARD_r00 1244 +#define _INSTRUMENTED_JUMP_FORWARD_r11 1245 +#define _INSTRUMENTED_JUMP_FORWARD_r22 1246 +#define _INSTRUMENTED_JUMP_FORWARD_r33 1247 +#define _INSTRUMENTED_JUMP_FORWARD_r44 1248 +#define _INSTRUMENTED_JUMP_FORWARD_r55 1249 +#define _INSTRUMENTED_LINE_r00 1250 +#define _INSTRUMENTED_NOT_TAKEN_r00 1251 +#define _INSTRUMENTED_NOT_TAKEN_r11 1252 +#define _INSTRUMENTED_NOT_TAKEN_r22 1253 +#define _INSTRUMENTED_NOT_TAKEN_r33 1254 +#define _INSTRUMENTED_NOT_TAKEN_r44 1255 +#define _INSTRUMENTED_NOT_TAKEN_r55 1256 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r00 1257 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r10 1258 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r21 1259 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r32 1260 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r43 1261 +#define _INSTRUMENTED_POP_JUMP_IF_FALSE_r54 1262 +#define _INSTRUMENTED_POP_JUMP_IF_NONE_r10 1263 +#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE_r10 1264 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r00 1265 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r10 1266 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r21 1267 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r32 1268 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r43 1269 +#define _INSTRUMENTED_POP_JUMP_IF_TRUE_r54 1270 +#define _IS_NONE_r11 1271 +#define _IS_OP_r03 1272 +#define _IS_OP_r13 1273 +#define _IS_OP_r23 1274 +#define _IS_OP_r34 1275 +#define _IS_OP_r45 1276 +#define _ITER_CHECK_LIST_r02 1277 +#define _ITER_CHECK_LIST_r12 1278 +#define _ITER_CHECK_LIST_r22 1279 +#define _ITER_CHECK_LIST_r33 1280 +#define _ITER_CHECK_LIST_r44 1281 +#define _ITER_CHECK_LIST_r55 1282 +#define _ITER_CHECK_RANGE_r02 1283 +#define _ITER_CHECK_RANGE_r12 1284 +#define _ITER_CHECK_RANGE_r22 1285 +#define _ITER_CHECK_RANGE_r33 1286 +#define _ITER_CHECK_RANGE_r44 1287 +#define _ITER_CHECK_RANGE_r55 1288 +#define _ITER_CHECK_TUPLE_r02 1289 +#define _ITER_CHECK_TUPLE_r12 1290 +#define _ITER_CHECK_TUPLE_r22 1291 +#define _ITER_CHECK_TUPLE_r33 1292 +#define _ITER_CHECK_TUPLE_r44 1293 +#define _ITER_CHECK_TUPLE_r55 1294 +#define _ITER_JUMP_LIST_r02 1295 +#define _ITER_JUMP_LIST_r12 1296 +#define _ITER_JUMP_LIST_r22 1297 +#define _ITER_JUMP_LIST_r33 1298 +#define _ITER_JUMP_LIST_r44 1299 +#define _ITER_JUMP_LIST_r55 1300 +#define _ITER_JUMP_RANGE_r02 1301 +#define _ITER_JUMP_RANGE_r12 1302 +#define _ITER_JUMP_RANGE_r22 1303 +#define _ITER_JUMP_RANGE_r33 1304 +#define _ITER_JUMP_RANGE_r44 1305 +#define _ITER_JUMP_RANGE_r55 1306 +#define _ITER_JUMP_TUPLE_r02 1307 +#define _ITER_JUMP_TUPLE_r12 1308 +#define _ITER_JUMP_TUPLE_r22 1309 +#define _ITER_JUMP_TUPLE_r33 1310 +#define _ITER_JUMP_TUPLE_r44 1311 +#define _ITER_JUMP_TUPLE_r55 1312 +#define _ITER_NEXT_LIST_r23 1313 +#define _ITER_NEXT_LIST_TIER_TWO_r23 1314 +#define _ITER_NEXT_RANGE_r03 1315 +#define _ITER_NEXT_RANGE_r13 1316 +#define _ITER_NEXT_RANGE_r23 1317 +#define _ITER_NEXT_RANGE_r34 1318 +#define _ITER_NEXT_RANGE_r45 1319 +#define _ITER_NEXT_TUPLE_r03 1320 +#define _ITER_NEXT_TUPLE_r13 1321 +#define _ITER_NEXT_TUPLE_r23 1322 +#define _ITER_NEXT_TUPLE_r34 1323 +#define _ITER_NEXT_TUPLE_r45 1324 +#define _JUMP_BACKWARD_NO_INTERRUPT_r00 1325 +#define _JUMP_BACKWARD_NO_INTERRUPT_r11 1326 +#define _JUMP_BACKWARD_NO_INTERRUPT_r22 1327 +#define _JUMP_BACKWARD_NO_INTERRUPT_r33 1328 +#define _JUMP_BACKWARD_NO_INTERRUPT_r44 1329 +#define _JUMP_BACKWARD_NO_INTERRUPT_r55 1330 +#define _JUMP_TO_TOP_r00 1331 +#define _LIST_APPEND_r10 1332 +#define _LIST_EXTEND_r10 1333 +#define _LOAD_ATTR_r10 1334 +#define _LOAD_ATTR_CLASS_r11 1335 +#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN_r11 1336 +#define _LOAD_ATTR_INSTANCE_VALUE_r02 1337 +#define _LOAD_ATTR_INSTANCE_VALUE_r12 1338 +#define _LOAD_ATTR_INSTANCE_VALUE_r23 1339 +#define _LOAD_ATTR_INSTANCE_VALUE_r34 1340 +#define _LOAD_ATTR_INSTANCE_VALUE_r45 1341 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r02 1342 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r12 1343 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r23 1344 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r34 1345 +#define _LOAD_ATTR_METHOD_LAZY_DICT_r45 1346 +#define _LOAD_ATTR_METHOD_NO_DICT_r02 1347 +#define _LOAD_ATTR_METHOD_NO_DICT_r12 1348 +#define _LOAD_ATTR_METHOD_NO_DICT_r23 1349 +#define _LOAD_ATTR_METHOD_NO_DICT_r34 1350 +#define _LOAD_ATTR_METHOD_NO_DICT_r45 1351 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r02 1352 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r12 1353 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r23 1354 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r34 1355 +#define _LOAD_ATTR_METHOD_WITH_VALUES_r45 1356 +#define _LOAD_ATTR_MODULE_r12 1357 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 1358 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 1359 +#define _LOAD_ATTR_PROPERTY_FRAME_r11 1360 +#define _LOAD_ATTR_SLOT_r02 1361 +#define _LOAD_ATTR_SLOT_r12 1362 +#define _LOAD_ATTR_SLOT_r23 1363 +#define _LOAD_ATTR_SLOT_r34 1364 +#define _LOAD_ATTR_SLOT_r45 1365 +#define _LOAD_ATTR_WITH_HINT_r12 1366 +#define _LOAD_BUILD_CLASS_r01 1367 +#define _LOAD_BYTECODE_r00 1368 +#define _LOAD_COMMON_CONSTANT_r01 1369 +#define _LOAD_COMMON_CONSTANT_r12 1370 +#define _LOAD_COMMON_CONSTANT_r23 1371 +#define _LOAD_COMMON_CONSTANT_r34 1372 +#define _LOAD_COMMON_CONSTANT_r45 1373 +#define _LOAD_CONST_r01 1374 +#define _LOAD_CONST_r12 1375 +#define _LOAD_CONST_r23 1376 +#define _LOAD_CONST_r34 1377 +#define _LOAD_CONST_r45 1378 +#define _LOAD_CONST_INLINE_r01 1379 +#define _LOAD_CONST_INLINE_r12 1380 +#define _LOAD_CONST_INLINE_r23 1381 +#define _LOAD_CONST_INLINE_r34 1382 +#define _LOAD_CONST_INLINE_r45 1383 +#define _LOAD_CONST_INLINE_BORROW_r01 1384 +#define _LOAD_CONST_INLINE_BORROW_r12 1385 +#define _LOAD_CONST_INLINE_BORROW_r23 1386 +#define _LOAD_CONST_INLINE_BORROW_r34 1387 +#define _LOAD_CONST_INLINE_BORROW_r45 1388 +#define _LOAD_CONST_UNDER_INLINE_r02 1389 +#define _LOAD_CONST_UNDER_INLINE_r12 1390 +#define _LOAD_CONST_UNDER_INLINE_r23 1391 +#define _LOAD_CONST_UNDER_INLINE_r34 1392 +#define _LOAD_CONST_UNDER_INLINE_r45 1393 +#define _LOAD_CONST_UNDER_INLINE_BORROW_r02 1394 +#define _LOAD_CONST_UNDER_INLINE_BORROW_r12 1395 +#define _LOAD_CONST_UNDER_INLINE_BORROW_r23 1396 +#define _LOAD_CONST_UNDER_INLINE_BORROW_r34 1397 +#define _LOAD_CONST_UNDER_INLINE_BORROW_r45 1398 +#define _LOAD_DEREF_r01 1399 +#define _LOAD_FAST_r01 1400 +#define _LOAD_FAST_r12 1401 +#define _LOAD_FAST_r23 1402 +#define _LOAD_FAST_r34 1403 +#define _LOAD_FAST_r45 1404 +#define _LOAD_FAST_0_r01 1405 +#define _LOAD_FAST_0_r12 1406 +#define _LOAD_FAST_0_r23 1407 +#define _LOAD_FAST_0_r34 1408 +#define _LOAD_FAST_0_r45 1409 +#define _LOAD_FAST_1_r01 1410 +#define _LOAD_FAST_1_r12 1411 +#define _LOAD_FAST_1_r23 1412 +#define _LOAD_FAST_1_r34 1413 +#define _LOAD_FAST_1_r45 1414 +#define _LOAD_FAST_2_r01 1415 +#define _LOAD_FAST_2_r12 1416 +#define _LOAD_FAST_2_r23 1417 +#define _LOAD_FAST_2_r34 1418 +#define _LOAD_FAST_2_r45 1419 +#define _LOAD_FAST_3_r01 1420 +#define _LOAD_FAST_3_r12 1421 +#define _LOAD_FAST_3_r23 1422 +#define _LOAD_FAST_3_r34 1423 +#define _LOAD_FAST_3_r45 1424 +#define _LOAD_FAST_4_r01 1425 +#define _LOAD_FAST_4_r12 1426 +#define _LOAD_FAST_4_r23 1427 +#define _LOAD_FAST_4_r34 1428 +#define _LOAD_FAST_4_r45 1429 +#define _LOAD_FAST_5_r01 1430 +#define _LOAD_FAST_5_r12 1431 +#define _LOAD_FAST_5_r23 1432 +#define _LOAD_FAST_5_r34 1433 +#define _LOAD_FAST_5_r45 1434 +#define _LOAD_FAST_6_r01 1435 +#define _LOAD_FAST_6_r12 1436 +#define _LOAD_FAST_6_r23 1437 +#define _LOAD_FAST_6_r34 1438 +#define _LOAD_FAST_6_r45 1439 +#define _LOAD_FAST_7_r01 1440 +#define _LOAD_FAST_7_r12 1441 +#define _LOAD_FAST_7_r23 1442 +#define _LOAD_FAST_7_r34 1443 +#define _LOAD_FAST_7_r45 1444 +#define _LOAD_FAST_AND_CLEAR_r01 1445 +#define _LOAD_FAST_AND_CLEAR_r12 1446 +#define _LOAD_FAST_AND_CLEAR_r23 1447 +#define _LOAD_FAST_AND_CLEAR_r34 1448 +#define _LOAD_FAST_AND_CLEAR_r45 1449 +#define _LOAD_FAST_BORROW_r01 1450 +#define _LOAD_FAST_BORROW_r12 1451 +#define _LOAD_FAST_BORROW_r23 1452 +#define _LOAD_FAST_BORROW_r34 1453 +#define _LOAD_FAST_BORROW_r45 1454 +#define _LOAD_FAST_BORROW_0_r01 1455 +#define _LOAD_FAST_BORROW_0_r12 1456 +#define _LOAD_FAST_BORROW_0_r23 1457 +#define _LOAD_FAST_BORROW_0_r34 1458 +#define _LOAD_FAST_BORROW_0_r45 1459 +#define _LOAD_FAST_BORROW_1_r01 1460 +#define _LOAD_FAST_BORROW_1_r12 1461 +#define _LOAD_FAST_BORROW_1_r23 1462 +#define _LOAD_FAST_BORROW_1_r34 1463 +#define _LOAD_FAST_BORROW_1_r45 1464 +#define _LOAD_FAST_BORROW_2_r01 1465 +#define _LOAD_FAST_BORROW_2_r12 1466 +#define _LOAD_FAST_BORROW_2_r23 1467 +#define _LOAD_FAST_BORROW_2_r34 1468 +#define _LOAD_FAST_BORROW_2_r45 1469 +#define _LOAD_FAST_BORROW_3_r01 1470 +#define _LOAD_FAST_BORROW_3_r12 1471 +#define _LOAD_FAST_BORROW_3_r23 1472 +#define _LOAD_FAST_BORROW_3_r34 1473 +#define _LOAD_FAST_BORROW_3_r45 1474 +#define _LOAD_FAST_BORROW_4_r01 1475 +#define _LOAD_FAST_BORROW_4_r12 1476 +#define _LOAD_FAST_BORROW_4_r23 1477 +#define _LOAD_FAST_BORROW_4_r34 1478 +#define _LOAD_FAST_BORROW_4_r45 1479 +#define _LOAD_FAST_BORROW_5_r01 1480 +#define _LOAD_FAST_BORROW_5_r12 1481 +#define _LOAD_FAST_BORROW_5_r23 1482 +#define _LOAD_FAST_BORROW_5_r34 1483 +#define _LOAD_FAST_BORROW_5_r45 1484 +#define _LOAD_FAST_BORROW_6_r01 1485 +#define _LOAD_FAST_BORROW_6_r12 1486 +#define _LOAD_FAST_BORROW_6_r23 1487 +#define _LOAD_FAST_BORROW_6_r34 1488 +#define _LOAD_FAST_BORROW_6_r45 1489 +#define _LOAD_FAST_BORROW_7_r01 1490 +#define _LOAD_FAST_BORROW_7_r12 1491 +#define _LOAD_FAST_BORROW_7_r23 1492 +#define _LOAD_FAST_BORROW_7_r34 1493 +#define _LOAD_FAST_BORROW_7_r45 1494 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r02 1495 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r13 1496 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r24 1497 +#define _LOAD_FAST_BORROW_LOAD_FAST_BORROW_r35 1498 +#define _LOAD_FAST_CHECK_r01 1499 +#define _LOAD_FAST_CHECK_r12 1500 +#define _LOAD_FAST_CHECK_r23 1501 +#define _LOAD_FAST_CHECK_r34 1502 +#define _LOAD_FAST_CHECK_r45 1503 +#define _LOAD_FAST_LOAD_FAST_r02 1504 +#define _LOAD_FAST_LOAD_FAST_r13 1505 +#define _LOAD_FAST_LOAD_FAST_r24 1506 +#define _LOAD_FAST_LOAD_FAST_r35 1507 +#define _LOAD_FROM_DICT_OR_DEREF_r11 1508 +#define _LOAD_FROM_DICT_OR_GLOBALS_r11 1509 +#define _LOAD_GLOBAL_r00 1510 +#define _LOAD_GLOBAL_BUILTINS_r01 1511 +#define _LOAD_GLOBAL_MODULE_r01 1512 +#define _LOAD_LOCALS_r01 1513 +#define _LOAD_LOCALS_r12 1514 +#define _LOAD_LOCALS_r23 1515 +#define _LOAD_LOCALS_r34 1516 +#define _LOAD_LOCALS_r45 1517 +#define _LOAD_NAME_r01 1518 +#define _LOAD_SMALL_INT_r01 1519 +#define _LOAD_SMALL_INT_r12 1520 +#define _LOAD_SMALL_INT_r23 1521 +#define _LOAD_SMALL_INT_r34 1522 +#define _LOAD_SMALL_INT_r45 1523 +#define _LOAD_SMALL_INT_0_r01 1524 +#define _LOAD_SMALL_INT_0_r12 1525 +#define _LOAD_SMALL_INT_0_r23 1526 +#define _LOAD_SMALL_INT_0_r34 1527 +#define _LOAD_SMALL_INT_0_r45 1528 +#define _LOAD_SMALL_INT_1_r01 1529 +#define _LOAD_SMALL_INT_1_r12 1530 +#define _LOAD_SMALL_INT_1_r23 1531 +#define _LOAD_SMALL_INT_1_r34 1532 +#define _LOAD_SMALL_INT_1_r45 1533 +#define _LOAD_SMALL_INT_2_r01 1534 +#define _LOAD_SMALL_INT_2_r12 1535 +#define _LOAD_SMALL_INT_2_r23 1536 +#define _LOAD_SMALL_INT_2_r34 1537 +#define _LOAD_SMALL_INT_2_r45 1538 +#define _LOAD_SMALL_INT_3_r01 1539 +#define _LOAD_SMALL_INT_3_r12 1540 +#define _LOAD_SMALL_INT_3_r23 1541 +#define _LOAD_SMALL_INT_3_r34 1542 +#define _LOAD_SMALL_INT_3_r45 1543 +#define _LOAD_SPECIAL_r00 1544 +#define _LOAD_SUPER_ATTR_ATTR_r31 1545 +#define _LOAD_SUPER_ATTR_METHOD_r32 1546 +#define _MAKE_CALLARGS_A_TUPLE_r44 1547 +#define _MAKE_CELL_r00 1548 +#define _MAKE_FUNCTION_r11 1549 +#define _MAKE_WARM_r00 1550 +#define _MAKE_WARM_r11 1551 +#define _MAKE_WARM_r22 1552 +#define _MAKE_WARM_r33 1553 +#define _MAKE_WARM_r44 1554 +#define _MAKE_WARM_r55 1555 +#define _MAP_ADD_r20 1556 +#define _MATCH_CLASS_r31 1557 +#define _MATCH_KEYS_r23 1558 +#define _MATCH_MAPPING_r02 1559 +#define _MATCH_MAPPING_r12 1560 +#define _MATCH_MAPPING_r23 1561 +#define _MATCH_MAPPING_r34 1562 +#define _MATCH_MAPPING_r45 1563 +#define _MATCH_SEQUENCE_r02 1564 +#define _MATCH_SEQUENCE_r12 1565 +#define _MATCH_SEQUENCE_r23 1566 +#define _MATCH_SEQUENCE_r34 1567 +#define _MATCH_SEQUENCE_r45 1568 +#define _MAYBE_EXPAND_METHOD_r00 1569 +#define _MAYBE_EXPAND_METHOD_KW_r11 1570 +#define _MONITOR_CALL_r00 1571 +#define _MONITOR_CALL_KW_r11 1572 +#define _MONITOR_JUMP_BACKWARD_r00 1573 +#define _MONITOR_JUMP_BACKWARD_r11 1574 +#define _MONITOR_JUMP_BACKWARD_r22 1575 +#define _MONITOR_JUMP_BACKWARD_r33 1576 +#define _MONITOR_JUMP_BACKWARD_r44 1577 +#define _MONITOR_JUMP_BACKWARD_r55 1578 +#define _MONITOR_RESUME_r00 1579 +#define _NOP_r00 1580 +#define _NOP_r11 1581 +#define _NOP_r22 1582 +#define _NOP_r33 1583 +#define _NOP_r44 1584 +#define _NOP_r55 1585 +#define _POP_CALL_r20 1586 +#define _POP_CALL_LOAD_CONST_INLINE_BORROW_r21 1587 +#define _POP_CALL_ONE_r30 1588 +#define _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31 1589 +#define _POP_CALL_TWO_r40 1590 +#define _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r41 1591 +#define _POP_EXCEPT_r10 1592 +#define _POP_ITER_r20 1593 +#define _POP_JUMP_IF_FALSE_r00 1594 +#define _POP_JUMP_IF_FALSE_r10 1595 +#define _POP_JUMP_IF_FALSE_r21 1596 +#define _POP_JUMP_IF_FALSE_r32 1597 +#define _POP_JUMP_IF_FALSE_r43 1598 +#define _POP_JUMP_IF_FALSE_r54 1599 +#define _POP_JUMP_IF_TRUE_r00 1600 +#define _POP_JUMP_IF_TRUE_r10 1601 +#define _POP_JUMP_IF_TRUE_r21 1602 +#define _POP_JUMP_IF_TRUE_r32 1603 +#define _POP_JUMP_IF_TRUE_r43 1604 +#define _POP_JUMP_IF_TRUE_r54 1605 +#define _POP_TOP_r10 1606 +#define _POP_TOP_FLOAT_r00 1607 +#define _POP_TOP_FLOAT_r10 1608 +#define _POP_TOP_FLOAT_r21 1609 +#define _POP_TOP_FLOAT_r32 1610 +#define _POP_TOP_FLOAT_r43 1611 +#define _POP_TOP_FLOAT_r54 1612 +#define _POP_TOP_INT_r00 1613 +#define _POP_TOP_INT_r10 1614 +#define _POP_TOP_INT_r21 1615 +#define _POP_TOP_INT_r32 1616 +#define _POP_TOP_INT_r43 1617 +#define _POP_TOP_INT_r54 1618 +#define _POP_TOP_LOAD_CONST_INLINE_r11 1619 +#define _POP_TOP_LOAD_CONST_INLINE_BORROW_r11 1620 +#define _POP_TOP_NOP_r00 1621 +#define _POP_TOP_NOP_r10 1622 +#define _POP_TOP_NOP_r21 1623 +#define _POP_TOP_NOP_r32 1624 +#define _POP_TOP_NOP_r43 1625 +#define _POP_TOP_NOP_r54 1626 +#define _POP_TOP_UNICODE_r00 1627 +#define _POP_TOP_UNICODE_r10 1628 +#define _POP_TOP_UNICODE_r21 1629 +#define _POP_TOP_UNICODE_r32 1630 +#define _POP_TOP_UNICODE_r43 1631 +#define _POP_TOP_UNICODE_r54 1632 +#define _POP_TWO_r20 1633 +#define _POP_TWO_LOAD_CONST_INLINE_BORROW_r21 1634 +#define _PUSH_EXC_INFO_r02 1635 +#define _PUSH_EXC_INFO_r12 1636 +#define _PUSH_EXC_INFO_r23 1637 +#define _PUSH_EXC_INFO_r34 1638 +#define _PUSH_EXC_INFO_r45 1639 +#define _PUSH_FRAME_r10 1640 +#define _PUSH_NULL_r01 1641 +#define _PUSH_NULL_r12 1642 +#define _PUSH_NULL_r23 1643 +#define _PUSH_NULL_r34 1644 +#define _PUSH_NULL_r45 1645 +#define _PUSH_NULL_CONDITIONAL_r00 1646 +#define _PY_FRAME_EX_r41 1647 +#define _PY_FRAME_GENERAL_r01 1648 +#define _PY_FRAME_KW_r11 1649 +#define _QUICKEN_RESUME_r00 1650 +#define _QUICKEN_RESUME_r11 1651 +#define _QUICKEN_RESUME_r22 1652 +#define _QUICKEN_RESUME_r33 1653 +#define _QUICKEN_RESUME_r44 1654 +#define _QUICKEN_RESUME_r55 1655 +#define _REPLACE_WITH_TRUE_r02 1656 +#define _REPLACE_WITH_TRUE_r12 1657 +#define _REPLACE_WITH_TRUE_r23 1658 +#define _REPLACE_WITH_TRUE_r34 1659 +#define _REPLACE_WITH_TRUE_r45 1660 +#define _RESUME_CHECK_r00 1661 +#define _RESUME_CHECK_r11 1662 +#define _RESUME_CHECK_r22 1663 +#define _RESUME_CHECK_r33 1664 +#define _RESUME_CHECK_r44 1665 +#define _RESUME_CHECK_r55 1666 +#define _RETURN_GENERATOR_r01 1667 +#define _RETURN_VALUE_r11 1668 +#define _SAVE_RETURN_OFFSET_r00 1669 +#define _SAVE_RETURN_OFFSET_r11 1670 +#define _SAVE_RETURN_OFFSET_r22 1671 +#define _SAVE_RETURN_OFFSET_r33 1672 +#define _SAVE_RETURN_OFFSET_r44 1673 +#define _SAVE_RETURN_OFFSET_r55 1674 +#define _SEND_r22 1675 +#define _SEND_GEN_FRAME_r22 1676 +#define _SETUP_ANNOTATIONS_r00 1677 +#define _SET_ADD_r10 1678 +#define _SET_FUNCTION_ATTRIBUTE_r01 1679 +#define _SET_FUNCTION_ATTRIBUTE_r11 1680 +#define _SET_FUNCTION_ATTRIBUTE_r21 1681 +#define _SET_FUNCTION_ATTRIBUTE_r32 1682 +#define _SET_FUNCTION_ATTRIBUTE_r43 1683 +#define _SET_FUNCTION_ATTRIBUTE_r54 1684 +#define _SET_IP_r00 1685 +#define _SET_IP_r11 1686 +#define _SET_IP_r22 1687 +#define _SET_IP_r33 1688 +#define _SET_IP_r44 1689 +#define _SET_IP_r55 1690 +#define _SET_UPDATE_r10 1691 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r02 1692 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12 1693 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22 1694 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32 1695 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r43 1696 +#define _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r54 1697 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03 1698 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13 1699 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23 1700 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33 1701 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r44 1702 +#define _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r55 1703 +#define _SPILL_OR_RELOAD_r01 1704 +#define _SPILL_OR_RELOAD_r02 1705 +#define _SPILL_OR_RELOAD_r03 1706 +#define _SPILL_OR_RELOAD_r04 1707 +#define _SPILL_OR_RELOAD_r05 1708 +#define _SPILL_OR_RELOAD_r10 1709 +#define _SPILL_OR_RELOAD_r12 1710 +#define _SPILL_OR_RELOAD_r13 1711 +#define _SPILL_OR_RELOAD_r14 1712 +#define _SPILL_OR_RELOAD_r15 1713 +#define _SPILL_OR_RELOAD_r20 1714 +#define _SPILL_OR_RELOAD_r21 1715 +#define _SPILL_OR_RELOAD_r23 1716 +#define _SPILL_OR_RELOAD_r24 1717 +#define _SPILL_OR_RELOAD_r25 1718 +#define _SPILL_OR_RELOAD_r30 1719 +#define _SPILL_OR_RELOAD_r31 1720 +#define _SPILL_OR_RELOAD_r32 1721 +#define _SPILL_OR_RELOAD_r34 1722 +#define _SPILL_OR_RELOAD_r35 1723 +#define _SPILL_OR_RELOAD_r40 1724 +#define _SPILL_OR_RELOAD_r41 1725 +#define _SPILL_OR_RELOAD_r42 1726 +#define _SPILL_OR_RELOAD_r43 1727 +#define _SPILL_OR_RELOAD_r45 1728 +#define _SPILL_OR_RELOAD_r50 1729 +#define _SPILL_OR_RELOAD_r51 1730 +#define _SPILL_OR_RELOAD_r52 1731 +#define _SPILL_OR_RELOAD_r53 1732 +#define _SPILL_OR_RELOAD_r54 1733 +#define _START_EXECUTOR_r00 1734 +#define _STORE_ATTR_r20 1735 +#define _STORE_ATTR_INSTANCE_VALUE_r21 1736 +#define _STORE_ATTR_SLOT_r21 1737 +#define _STORE_ATTR_WITH_HINT_r21 1738 +#define _STORE_DEREF_r10 1739 +#define _STORE_FAST_LOAD_FAST_r11 1740 +#define _STORE_FAST_STORE_FAST_r20 1741 +#define _STORE_GLOBAL_r10 1742 +#define _STORE_NAME_r10 1743 +#define _STORE_SLICE_r40 1744 +#define _STORE_SUBSCR_r30 1745 +#define _STORE_SUBSCR_DICT_r31 1746 +#define _STORE_SUBSCR_LIST_INT_r32 1747 +#define _SWAP_r11 1748 +#define _SWAP_2_r02 1749 +#define _SWAP_2_r12 1750 +#define _SWAP_2_r22 1751 +#define _SWAP_2_r33 1752 +#define _SWAP_2_r44 1753 +#define _SWAP_2_r55 1754 +#define _SWAP_3_r03 1755 +#define _SWAP_3_r13 1756 +#define _SWAP_3_r23 1757 +#define _SWAP_3_r33 1758 +#define _SWAP_3_r44 1759 +#define _SWAP_3_r55 1760 +#define _SWAP_FAST_r01 1761 +#define _SWAP_FAST_r11 1762 +#define _SWAP_FAST_r22 1763 +#define _SWAP_FAST_r33 1764 +#define _SWAP_FAST_r44 1765 +#define _SWAP_FAST_r55 1766 +#define _SWAP_FAST_0_r01 1767 +#define _SWAP_FAST_0_r11 1768 +#define _SWAP_FAST_0_r22 1769 +#define _SWAP_FAST_0_r33 1770 +#define _SWAP_FAST_0_r44 1771 +#define _SWAP_FAST_0_r55 1772 +#define _SWAP_FAST_1_r01 1773 +#define _SWAP_FAST_1_r11 1774 +#define _SWAP_FAST_1_r22 1775 +#define _SWAP_FAST_1_r33 1776 +#define _SWAP_FAST_1_r44 1777 +#define _SWAP_FAST_1_r55 1778 +#define _SWAP_FAST_2_r01 1779 +#define _SWAP_FAST_2_r11 1780 +#define _SWAP_FAST_2_r22 1781 +#define _SWAP_FAST_2_r33 1782 +#define _SWAP_FAST_2_r44 1783 +#define _SWAP_FAST_2_r55 1784 +#define _SWAP_FAST_3_r01 1785 +#define _SWAP_FAST_3_r11 1786 +#define _SWAP_FAST_3_r22 1787 +#define _SWAP_FAST_3_r33 1788 +#define _SWAP_FAST_3_r44 1789 +#define _SWAP_FAST_3_r55 1790 +#define _SWAP_FAST_4_r01 1791 +#define _SWAP_FAST_4_r11 1792 +#define _SWAP_FAST_4_r22 1793 +#define _SWAP_FAST_4_r33 1794 +#define _SWAP_FAST_4_r44 1795 +#define _SWAP_FAST_4_r55 1796 +#define _SWAP_FAST_5_r01 1797 +#define _SWAP_FAST_5_r11 1798 +#define _SWAP_FAST_5_r22 1799 +#define _SWAP_FAST_5_r33 1800 +#define _SWAP_FAST_5_r44 1801 +#define _SWAP_FAST_5_r55 1802 +#define _SWAP_FAST_6_r01 1803 +#define _SWAP_FAST_6_r11 1804 +#define _SWAP_FAST_6_r22 1805 +#define _SWAP_FAST_6_r33 1806 +#define _SWAP_FAST_6_r44 1807 +#define _SWAP_FAST_6_r55 1808 +#define _SWAP_FAST_7_r01 1809 +#define _SWAP_FAST_7_r11 1810 +#define _SWAP_FAST_7_r22 1811 +#define _SWAP_FAST_7_r33 1812 +#define _SWAP_FAST_7_r44 1813 +#define _SWAP_FAST_7_r55 1814 +#define _TIER2_RESUME_CHECK_r00 1815 +#define _TIER2_RESUME_CHECK_r11 1816 +#define _TIER2_RESUME_CHECK_r22 1817 +#define _TIER2_RESUME_CHECK_r33 1818 +#define _TIER2_RESUME_CHECK_r44 1819 +#define _TIER2_RESUME_CHECK_r55 1820 +#define _TO_BOOL_r11 1821 +#define _TO_BOOL_BOOL_r01 1822 +#define _TO_BOOL_BOOL_r11 1823 +#define _TO_BOOL_BOOL_r22 1824 +#define _TO_BOOL_BOOL_r33 1825 +#define _TO_BOOL_BOOL_r44 1826 +#define _TO_BOOL_BOOL_r55 1827 +#define _TO_BOOL_INT_r02 1828 +#define _TO_BOOL_INT_r12 1829 +#define _TO_BOOL_INT_r23 1830 +#define _TO_BOOL_INT_r34 1831 +#define _TO_BOOL_INT_r45 1832 +#define _TO_BOOL_LIST_r02 1833 +#define _TO_BOOL_LIST_r12 1834 +#define _TO_BOOL_LIST_r23 1835 +#define _TO_BOOL_LIST_r34 1836 +#define _TO_BOOL_LIST_r45 1837 +#define _TO_BOOL_NONE_r01 1838 +#define _TO_BOOL_NONE_r11 1839 +#define _TO_BOOL_NONE_r22 1840 +#define _TO_BOOL_NONE_r33 1841 +#define _TO_BOOL_NONE_r44 1842 +#define _TO_BOOL_NONE_r55 1843 +#define _TO_BOOL_STR_r02 1844 +#define _TO_BOOL_STR_r12 1845 +#define _TO_BOOL_STR_r23 1846 +#define _TO_BOOL_STR_r34 1847 +#define _TO_BOOL_STR_r45 1848 +#define _TRACE_RECORD_r00 1849 +#define _UNARY_INVERT_r12 1850 +#define _UNARY_NEGATIVE_r12 1851 +#define _UNARY_NOT_r01 1852 +#define _UNARY_NOT_r11 1853 +#define _UNARY_NOT_r22 1854 +#define _UNARY_NOT_r33 1855 +#define _UNARY_NOT_r44 1856 +#define _UNARY_NOT_r55 1857 +#define _UNPACK_EX_r10 1858 +#define _UNPACK_SEQUENCE_r10 1859 +#define _UNPACK_SEQUENCE_LIST_r10 1860 +#define _UNPACK_SEQUENCE_TUPLE_r10 1861 +#define _UNPACK_SEQUENCE_TWO_TUPLE_r12 1862 +#define _WITH_EXCEPT_START_r55 1863 +#define _YIELD_VALUE_r11 1864 +#define MAX_UOP_REGS_ID 1864 #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index c08f1e24fd1c12..1b66b97047e1ab 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -11,7 +11,6 @@ extern "C" { #include #include "pycore_uop_ids.h" -#define MAX_CACHED_REGISTER 3 extern const uint32_t _PyUop_Flags[MAX_UOP_ID+1]; typedef struct _rep_range { uint8_t start; uint8_t stop; } ReplicationRange; extern const ReplicationRange _PyUop_Replication[MAX_UOP_ID+1]; @@ -1142,12 +1141,12 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { }, }, [_STORE_SLICE] = { - .best = { 3, 3, 3, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, - { 0, 3, _STORE_SLICE_r30 }, + { -1, -1, -1 }, }, }, [_BINARY_OP_SUBSCR_LIST_INT] = { @@ -2267,12 +2266,12 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { }, }, [_WITH_EXCEPT_START] = { - .best = { 3, 3, 3, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, - { 3, 3, _WITH_EXCEPT_START_r33 }, + { -1, -1, -1 }, }, }, [_PUSH_EXC_INFO] = { @@ -2708,21 +2707,21 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { }, }, [_GUARD_CALLABLE_ISINSTANCE] = { - .best = { 0, 1, 2, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { - { 3, 0, _GUARD_CALLABLE_ISINSTANCE_r03 }, - { 3, 1, _GUARD_CALLABLE_ISINSTANCE_r13 }, - { 3, 2, _GUARD_CALLABLE_ISINSTANCE_r23 }, - { 3, 3, _GUARD_CALLABLE_ISINSTANCE_r33 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, }, }, [_CALL_ISINSTANCE] = { - .best = { 3, 3, 3, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, - { 1, 3, _CALL_ISINSTANCE_r31 }, + { -1, -1, -1 }, }, }, [_GUARD_CALLABLE_LIST_APPEND] = { @@ -2744,9 +2743,9 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { }, }, [_CALL_METHOD_DESCRIPTOR_O] = { - .best = { 0, 0, 0, 0 }, + .best = { 4, 4, 4, 4 }, .entries = { - { 3, 0, _CALL_METHOD_DESCRIPTOR_O_r03 }, + { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, @@ -2843,48 +2842,48 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { }, }, [_MAKE_CALLARGS_A_TUPLE] = { - .best = { 3, 3, 3, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, - { 3, 3, _MAKE_CALLARGS_A_TUPLE_r33 }, + { -1, -1, -1 }, }, }, [_CHECK_IS_PY_CALLABLE_EX] = { - .best = { 0, 1, 2, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { - { 3, 0, _CHECK_IS_PY_CALLABLE_EX_r03 }, - { 3, 1, _CHECK_IS_PY_CALLABLE_EX_r13 }, - { 3, 2, _CHECK_IS_PY_CALLABLE_EX_r23 }, - { 3, 3, _CHECK_IS_PY_CALLABLE_EX_r33 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, }, }, [_PY_FRAME_EX] = { - .best = { 3, 3, 3, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, - { 1, 1, _PY_FRAME_EX_r31 }, + { -1, -1, -1 }, }, }, [_CHECK_IS_NOT_PY_CALLABLE_EX] = { - .best = { 0, 1, 2, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { - { 3, 0, _CHECK_IS_NOT_PY_CALLABLE_EX_r03 }, - { 3, 1, _CHECK_IS_NOT_PY_CALLABLE_EX_r13 }, - { 3, 2, _CHECK_IS_NOT_PY_CALLABLE_EX_r23 }, - { 3, 3, _CHECK_IS_NOT_PY_CALLABLE_EX_r33 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, }, }, [_CALL_FUNCTION_EX_NON_PY_GENERAL] = { - .best = { 3, 3, 3, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, - { 1, 3, _CALL_FUNCTION_EX_NON_PY_GENERAL_r31 }, + { -1, -1, -1 }, }, }, [_MAKE_FUNCTION] = { @@ -2969,12 +2968,12 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { }, }, [_COPY_3] = { - .best = { 0, 1, 2, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { - { 3, 0, _COPY_3_r03 }, - { 3, 1, _COPY_3_r13 }, - { 3, 2, _COPY_3_r23 }, - { 3, 3, _COPY_3_r33 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, + { -1, -1, -1 }, }, }, [_COPY] = { @@ -3257,12 +3256,12 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { }, }, [_POP_CALL_TWO] = { - .best = { 3, 3, 3, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, - { 0, 3, _POP_CALL_TWO_r30 }, + { -1, -1, -1 }, }, }, [_POP_TOP_LOAD_CONST_INLINE_BORROW] = { @@ -3347,12 +3346,12 @@ const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = { }, }, [_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW] = { - .best = { 3, 3, 3, 3 }, + .best = { 4, 4, 4, 4 }, .entries = { { -1, -1, -1 }, { -1, -1, -1 }, { -1, -1, -1 }, - { 1, 3, _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31 }, + { -1, -1, -1 }, }, }, [_LOAD_CONST_UNDER_INLINE] = { @@ -3506,147 +3505,231 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_NOP_r11] = _NOP, [_NOP_r22] = _NOP, [_NOP_r33] = _NOP, + [_NOP_r44] = _NOP, + [_NOP_r55] = _NOP, [_CHECK_PERIODIC_r00] = _CHECK_PERIODIC, [_CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00] = _CHECK_PERIODIC_IF_NOT_YIELD_FROM, [_RESUME_CHECK_r00] = _RESUME_CHECK, [_RESUME_CHECK_r11] = _RESUME_CHECK, [_RESUME_CHECK_r22] = _RESUME_CHECK, [_RESUME_CHECK_r33] = _RESUME_CHECK, + [_RESUME_CHECK_r44] = _RESUME_CHECK, + [_RESUME_CHECK_r55] = _RESUME_CHECK, [_LOAD_FAST_CHECK_r01] = _LOAD_FAST_CHECK, [_LOAD_FAST_CHECK_r12] = _LOAD_FAST_CHECK, [_LOAD_FAST_CHECK_r23] = _LOAD_FAST_CHECK, + [_LOAD_FAST_CHECK_r34] = _LOAD_FAST_CHECK, + [_LOAD_FAST_CHECK_r45] = _LOAD_FAST_CHECK, [_LOAD_FAST_0_r01] = _LOAD_FAST_0, [_LOAD_FAST_0_r12] = _LOAD_FAST_0, [_LOAD_FAST_0_r23] = _LOAD_FAST_0, + [_LOAD_FAST_0_r34] = _LOAD_FAST_0, + [_LOAD_FAST_0_r45] = _LOAD_FAST_0, [_LOAD_FAST_1_r01] = _LOAD_FAST_1, [_LOAD_FAST_1_r12] = _LOAD_FAST_1, [_LOAD_FAST_1_r23] = _LOAD_FAST_1, + [_LOAD_FAST_1_r34] = _LOAD_FAST_1, + [_LOAD_FAST_1_r45] = _LOAD_FAST_1, [_LOAD_FAST_2_r01] = _LOAD_FAST_2, [_LOAD_FAST_2_r12] = _LOAD_FAST_2, [_LOAD_FAST_2_r23] = _LOAD_FAST_2, + [_LOAD_FAST_2_r34] = _LOAD_FAST_2, + [_LOAD_FAST_2_r45] = _LOAD_FAST_2, [_LOAD_FAST_3_r01] = _LOAD_FAST_3, [_LOAD_FAST_3_r12] = _LOAD_FAST_3, [_LOAD_FAST_3_r23] = _LOAD_FAST_3, + [_LOAD_FAST_3_r34] = _LOAD_FAST_3, + [_LOAD_FAST_3_r45] = _LOAD_FAST_3, [_LOAD_FAST_4_r01] = _LOAD_FAST_4, [_LOAD_FAST_4_r12] = _LOAD_FAST_4, [_LOAD_FAST_4_r23] = _LOAD_FAST_4, + [_LOAD_FAST_4_r34] = _LOAD_FAST_4, + [_LOAD_FAST_4_r45] = _LOAD_FAST_4, [_LOAD_FAST_5_r01] = _LOAD_FAST_5, [_LOAD_FAST_5_r12] = _LOAD_FAST_5, [_LOAD_FAST_5_r23] = _LOAD_FAST_5, + [_LOAD_FAST_5_r34] = _LOAD_FAST_5, + [_LOAD_FAST_5_r45] = _LOAD_FAST_5, [_LOAD_FAST_6_r01] = _LOAD_FAST_6, [_LOAD_FAST_6_r12] = _LOAD_FAST_6, [_LOAD_FAST_6_r23] = _LOAD_FAST_6, + [_LOAD_FAST_6_r34] = _LOAD_FAST_6, + [_LOAD_FAST_6_r45] = _LOAD_FAST_6, [_LOAD_FAST_7_r01] = _LOAD_FAST_7, [_LOAD_FAST_7_r12] = _LOAD_FAST_7, [_LOAD_FAST_7_r23] = _LOAD_FAST_7, + [_LOAD_FAST_7_r34] = _LOAD_FAST_7, + [_LOAD_FAST_7_r45] = _LOAD_FAST_7, [_LOAD_FAST_r01] = _LOAD_FAST, [_LOAD_FAST_r12] = _LOAD_FAST, [_LOAD_FAST_r23] = _LOAD_FAST, + [_LOAD_FAST_r34] = _LOAD_FAST, + [_LOAD_FAST_r45] = _LOAD_FAST, [_LOAD_FAST_BORROW_0_r01] = _LOAD_FAST_BORROW_0, [_LOAD_FAST_BORROW_0_r12] = _LOAD_FAST_BORROW_0, [_LOAD_FAST_BORROW_0_r23] = _LOAD_FAST_BORROW_0, + [_LOAD_FAST_BORROW_0_r34] = _LOAD_FAST_BORROW_0, + [_LOAD_FAST_BORROW_0_r45] = _LOAD_FAST_BORROW_0, [_LOAD_FAST_BORROW_1_r01] = _LOAD_FAST_BORROW_1, [_LOAD_FAST_BORROW_1_r12] = _LOAD_FAST_BORROW_1, [_LOAD_FAST_BORROW_1_r23] = _LOAD_FAST_BORROW_1, + [_LOAD_FAST_BORROW_1_r34] = _LOAD_FAST_BORROW_1, + [_LOAD_FAST_BORROW_1_r45] = _LOAD_FAST_BORROW_1, [_LOAD_FAST_BORROW_2_r01] = _LOAD_FAST_BORROW_2, [_LOAD_FAST_BORROW_2_r12] = _LOAD_FAST_BORROW_2, [_LOAD_FAST_BORROW_2_r23] = _LOAD_FAST_BORROW_2, + [_LOAD_FAST_BORROW_2_r34] = _LOAD_FAST_BORROW_2, + [_LOAD_FAST_BORROW_2_r45] = _LOAD_FAST_BORROW_2, [_LOAD_FAST_BORROW_3_r01] = _LOAD_FAST_BORROW_3, [_LOAD_FAST_BORROW_3_r12] = _LOAD_FAST_BORROW_3, [_LOAD_FAST_BORROW_3_r23] = _LOAD_FAST_BORROW_3, + [_LOAD_FAST_BORROW_3_r34] = _LOAD_FAST_BORROW_3, + [_LOAD_FAST_BORROW_3_r45] = _LOAD_FAST_BORROW_3, [_LOAD_FAST_BORROW_4_r01] = _LOAD_FAST_BORROW_4, [_LOAD_FAST_BORROW_4_r12] = _LOAD_FAST_BORROW_4, [_LOAD_FAST_BORROW_4_r23] = _LOAD_FAST_BORROW_4, + [_LOAD_FAST_BORROW_4_r34] = _LOAD_FAST_BORROW_4, + [_LOAD_FAST_BORROW_4_r45] = _LOAD_FAST_BORROW_4, [_LOAD_FAST_BORROW_5_r01] = _LOAD_FAST_BORROW_5, [_LOAD_FAST_BORROW_5_r12] = _LOAD_FAST_BORROW_5, [_LOAD_FAST_BORROW_5_r23] = _LOAD_FAST_BORROW_5, + [_LOAD_FAST_BORROW_5_r34] = _LOAD_FAST_BORROW_5, + [_LOAD_FAST_BORROW_5_r45] = _LOAD_FAST_BORROW_5, [_LOAD_FAST_BORROW_6_r01] = _LOAD_FAST_BORROW_6, [_LOAD_FAST_BORROW_6_r12] = _LOAD_FAST_BORROW_6, [_LOAD_FAST_BORROW_6_r23] = _LOAD_FAST_BORROW_6, + [_LOAD_FAST_BORROW_6_r34] = _LOAD_FAST_BORROW_6, + [_LOAD_FAST_BORROW_6_r45] = _LOAD_FAST_BORROW_6, [_LOAD_FAST_BORROW_7_r01] = _LOAD_FAST_BORROW_7, [_LOAD_FAST_BORROW_7_r12] = _LOAD_FAST_BORROW_7, [_LOAD_FAST_BORROW_7_r23] = _LOAD_FAST_BORROW_7, + [_LOAD_FAST_BORROW_7_r34] = _LOAD_FAST_BORROW_7, + [_LOAD_FAST_BORROW_7_r45] = _LOAD_FAST_BORROW_7, [_LOAD_FAST_BORROW_r01] = _LOAD_FAST_BORROW, [_LOAD_FAST_BORROW_r12] = _LOAD_FAST_BORROW, [_LOAD_FAST_BORROW_r23] = _LOAD_FAST_BORROW, + [_LOAD_FAST_BORROW_r34] = _LOAD_FAST_BORROW, + [_LOAD_FAST_BORROW_r45] = _LOAD_FAST_BORROW, [_LOAD_FAST_AND_CLEAR_r01] = _LOAD_FAST_AND_CLEAR, [_LOAD_FAST_AND_CLEAR_r12] = _LOAD_FAST_AND_CLEAR, [_LOAD_FAST_AND_CLEAR_r23] = _LOAD_FAST_AND_CLEAR, + [_LOAD_FAST_AND_CLEAR_r34] = _LOAD_FAST_AND_CLEAR, + [_LOAD_FAST_AND_CLEAR_r45] = _LOAD_FAST_AND_CLEAR, [_LOAD_CONST_r01] = _LOAD_CONST, [_LOAD_CONST_r12] = _LOAD_CONST, [_LOAD_CONST_r23] = _LOAD_CONST, + [_LOAD_CONST_r34] = _LOAD_CONST, + [_LOAD_CONST_r45] = _LOAD_CONST, [_LOAD_SMALL_INT_0_r01] = _LOAD_SMALL_INT_0, [_LOAD_SMALL_INT_0_r12] = _LOAD_SMALL_INT_0, [_LOAD_SMALL_INT_0_r23] = _LOAD_SMALL_INT_0, + [_LOAD_SMALL_INT_0_r34] = _LOAD_SMALL_INT_0, + [_LOAD_SMALL_INT_0_r45] = _LOAD_SMALL_INT_0, [_LOAD_SMALL_INT_1_r01] = _LOAD_SMALL_INT_1, [_LOAD_SMALL_INT_1_r12] = _LOAD_SMALL_INT_1, [_LOAD_SMALL_INT_1_r23] = _LOAD_SMALL_INT_1, + [_LOAD_SMALL_INT_1_r34] = _LOAD_SMALL_INT_1, + [_LOAD_SMALL_INT_1_r45] = _LOAD_SMALL_INT_1, [_LOAD_SMALL_INT_2_r01] = _LOAD_SMALL_INT_2, [_LOAD_SMALL_INT_2_r12] = _LOAD_SMALL_INT_2, [_LOAD_SMALL_INT_2_r23] = _LOAD_SMALL_INT_2, + [_LOAD_SMALL_INT_2_r34] = _LOAD_SMALL_INT_2, + [_LOAD_SMALL_INT_2_r45] = _LOAD_SMALL_INT_2, [_LOAD_SMALL_INT_3_r01] = _LOAD_SMALL_INT_3, [_LOAD_SMALL_INT_3_r12] = _LOAD_SMALL_INT_3, [_LOAD_SMALL_INT_3_r23] = _LOAD_SMALL_INT_3, + [_LOAD_SMALL_INT_3_r34] = _LOAD_SMALL_INT_3, + [_LOAD_SMALL_INT_3_r45] = _LOAD_SMALL_INT_3, [_LOAD_SMALL_INT_r01] = _LOAD_SMALL_INT, [_LOAD_SMALL_INT_r12] = _LOAD_SMALL_INT, [_LOAD_SMALL_INT_r23] = _LOAD_SMALL_INT, + [_LOAD_SMALL_INT_r34] = _LOAD_SMALL_INT, + [_LOAD_SMALL_INT_r45] = _LOAD_SMALL_INT, [_SWAP_FAST_0_r01] = _SWAP_FAST_0, [_SWAP_FAST_0_r11] = _SWAP_FAST_0, [_SWAP_FAST_0_r22] = _SWAP_FAST_0, [_SWAP_FAST_0_r33] = _SWAP_FAST_0, + [_SWAP_FAST_0_r44] = _SWAP_FAST_0, + [_SWAP_FAST_0_r55] = _SWAP_FAST_0, [_SWAP_FAST_1_r01] = _SWAP_FAST_1, [_SWAP_FAST_1_r11] = _SWAP_FAST_1, [_SWAP_FAST_1_r22] = _SWAP_FAST_1, [_SWAP_FAST_1_r33] = _SWAP_FAST_1, + [_SWAP_FAST_1_r44] = _SWAP_FAST_1, + [_SWAP_FAST_1_r55] = _SWAP_FAST_1, [_SWAP_FAST_2_r01] = _SWAP_FAST_2, [_SWAP_FAST_2_r11] = _SWAP_FAST_2, [_SWAP_FAST_2_r22] = _SWAP_FAST_2, [_SWAP_FAST_2_r33] = _SWAP_FAST_2, + [_SWAP_FAST_2_r44] = _SWAP_FAST_2, + [_SWAP_FAST_2_r55] = _SWAP_FAST_2, [_SWAP_FAST_3_r01] = _SWAP_FAST_3, [_SWAP_FAST_3_r11] = _SWAP_FAST_3, [_SWAP_FAST_3_r22] = _SWAP_FAST_3, [_SWAP_FAST_3_r33] = _SWAP_FAST_3, + [_SWAP_FAST_3_r44] = _SWAP_FAST_3, + [_SWAP_FAST_3_r55] = _SWAP_FAST_3, [_SWAP_FAST_4_r01] = _SWAP_FAST_4, [_SWAP_FAST_4_r11] = _SWAP_FAST_4, [_SWAP_FAST_4_r22] = _SWAP_FAST_4, [_SWAP_FAST_4_r33] = _SWAP_FAST_4, + [_SWAP_FAST_4_r44] = _SWAP_FAST_4, + [_SWAP_FAST_4_r55] = _SWAP_FAST_4, [_SWAP_FAST_5_r01] = _SWAP_FAST_5, [_SWAP_FAST_5_r11] = _SWAP_FAST_5, [_SWAP_FAST_5_r22] = _SWAP_FAST_5, [_SWAP_FAST_5_r33] = _SWAP_FAST_5, + [_SWAP_FAST_5_r44] = _SWAP_FAST_5, + [_SWAP_FAST_5_r55] = _SWAP_FAST_5, [_SWAP_FAST_6_r01] = _SWAP_FAST_6, [_SWAP_FAST_6_r11] = _SWAP_FAST_6, [_SWAP_FAST_6_r22] = _SWAP_FAST_6, [_SWAP_FAST_6_r33] = _SWAP_FAST_6, + [_SWAP_FAST_6_r44] = _SWAP_FAST_6, + [_SWAP_FAST_6_r55] = _SWAP_FAST_6, [_SWAP_FAST_7_r01] = _SWAP_FAST_7, [_SWAP_FAST_7_r11] = _SWAP_FAST_7, [_SWAP_FAST_7_r22] = _SWAP_FAST_7, [_SWAP_FAST_7_r33] = _SWAP_FAST_7, + [_SWAP_FAST_7_r44] = _SWAP_FAST_7, + [_SWAP_FAST_7_r55] = _SWAP_FAST_7, [_SWAP_FAST_r01] = _SWAP_FAST, [_SWAP_FAST_r11] = _SWAP_FAST, [_SWAP_FAST_r22] = _SWAP_FAST, [_SWAP_FAST_r33] = _SWAP_FAST, + [_SWAP_FAST_r44] = _SWAP_FAST, + [_SWAP_FAST_r55] = _SWAP_FAST, [_POP_TOP_r10] = _POP_TOP, [_POP_TOP_NOP_r00] = _POP_TOP_NOP, [_POP_TOP_NOP_r10] = _POP_TOP_NOP, [_POP_TOP_NOP_r21] = _POP_TOP_NOP, [_POP_TOP_NOP_r32] = _POP_TOP_NOP, + [_POP_TOP_NOP_r43] = _POP_TOP_NOP, + [_POP_TOP_NOP_r54] = _POP_TOP_NOP, [_POP_TOP_INT_r00] = _POP_TOP_INT, [_POP_TOP_INT_r10] = _POP_TOP_INT, [_POP_TOP_INT_r21] = _POP_TOP_INT, [_POP_TOP_INT_r32] = _POP_TOP_INT, + [_POP_TOP_INT_r43] = _POP_TOP_INT, + [_POP_TOP_INT_r54] = _POP_TOP_INT, [_POP_TOP_FLOAT_r00] = _POP_TOP_FLOAT, [_POP_TOP_FLOAT_r10] = _POP_TOP_FLOAT, [_POP_TOP_FLOAT_r21] = _POP_TOP_FLOAT, [_POP_TOP_FLOAT_r32] = _POP_TOP_FLOAT, + [_POP_TOP_FLOAT_r43] = _POP_TOP_FLOAT, + [_POP_TOP_FLOAT_r54] = _POP_TOP_FLOAT, [_POP_TOP_UNICODE_r00] = _POP_TOP_UNICODE, [_POP_TOP_UNICODE_r10] = _POP_TOP_UNICODE, [_POP_TOP_UNICODE_r21] = _POP_TOP_UNICODE, [_POP_TOP_UNICODE_r32] = _POP_TOP_UNICODE, + [_POP_TOP_UNICODE_r43] = _POP_TOP_UNICODE, + [_POP_TOP_UNICODE_r54] = _POP_TOP_UNICODE, [_POP_TWO_r20] = _POP_TWO, [_PUSH_NULL_r01] = _PUSH_NULL, [_PUSH_NULL_r12] = _PUSH_NULL, [_PUSH_NULL_r23] = _PUSH_NULL, + [_PUSH_NULL_r34] = _PUSH_NULL, + [_PUSH_NULL_r45] = _PUSH_NULL, [_END_FOR_r10] = _END_FOR, [_POP_ITER_r20] = _POP_ITER, [_END_SEND_r21] = _END_SEND, @@ -3655,102 +3738,154 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_UNARY_NOT_r11] = _UNARY_NOT, [_UNARY_NOT_r22] = _UNARY_NOT, [_UNARY_NOT_r33] = _UNARY_NOT, + [_UNARY_NOT_r44] = _UNARY_NOT, + [_UNARY_NOT_r55] = _UNARY_NOT, [_TO_BOOL_r11] = _TO_BOOL, [_TO_BOOL_BOOL_r01] = _TO_BOOL_BOOL, [_TO_BOOL_BOOL_r11] = _TO_BOOL_BOOL, [_TO_BOOL_BOOL_r22] = _TO_BOOL_BOOL, [_TO_BOOL_BOOL_r33] = _TO_BOOL_BOOL, + [_TO_BOOL_BOOL_r44] = _TO_BOOL_BOOL, + [_TO_BOOL_BOOL_r55] = _TO_BOOL_BOOL, [_TO_BOOL_INT_r02] = _TO_BOOL_INT, [_TO_BOOL_INT_r12] = _TO_BOOL_INT, [_TO_BOOL_INT_r23] = _TO_BOOL_INT, + [_TO_BOOL_INT_r34] = _TO_BOOL_INT, + [_TO_BOOL_INT_r45] = _TO_BOOL_INT, [_GUARD_NOS_LIST_r02] = _GUARD_NOS_LIST, [_GUARD_NOS_LIST_r12] = _GUARD_NOS_LIST, [_GUARD_NOS_LIST_r22] = _GUARD_NOS_LIST, [_GUARD_NOS_LIST_r33] = _GUARD_NOS_LIST, + [_GUARD_NOS_LIST_r44] = _GUARD_NOS_LIST, + [_GUARD_NOS_LIST_r55] = _GUARD_NOS_LIST, [_GUARD_TOS_LIST_r01] = _GUARD_TOS_LIST, [_GUARD_TOS_LIST_r11] = _GUARD_TOS_LIST, [_GUARD_TOS_LIST_r22] = _GUARD_TOS_LIST, [_GUARD_TOS_LIST_r33] = _GUARD_TOS_LIST, + [_GUARD_TOS_LIST_r44] = _GUARD_TOS_LIST, + [_GUARD_TOS_LIST_r55] = _GUARD_TOS_LIST, [_GUARD_TOS_SLICE_r01] = _GUARD_TOS_SLICE, [_GUARD_TOS_SLICE_r11] = _GUARD_TOS_SLICE, [_GUARD_TOS_SLICE_r22] = _GUARD_TOS_SLICE, [_GUARD_TOS_SLICE_r33] = _GUARD_TOS_SLICE, + [_GUARD_TOS_SLICE_r44] = _GUARD_TOS_SLICE, + [_GUARD_TOS_SLICE_r55] = _GUARD_TOS_SLICE, [_TO_BOOL_LIST_r02] = _TO_BOOL_LIST, [_TO_BOOL_LIST_r12] = _TO_BOOL_LIST, [_TO_BOOL_LIST_r23] = _TO_BOOL_LIST, + [_TO_BOOL_LIST_r34] = _TO_BOOL_LIST, + [_TO_BOOL_LIST_r45] = _TO_BOOL_LIST, [_TO_BOOL_NONE_r01] = _TO_BOOL_NONE, [_TO_BOOL_NONE_r11] = _TO_BOOL_NONE, [_TO_BOOL_NONE_r22] = _TO_BOOL_NONE, [_TO_BOOL_NONE_r33] = _TO_BOOL_NONE, + [_TO_BOOL_NONE_r44] = _TO_BOOL_NONE, + [_TO_BOOL_NONE_r55] = _TO_BOOL_NONE, [_GUARD_NOS_COMPACT_ASCII_r02] = _GUARD_NOS_COMPACT_ASCII, [_GUARD_NOS_COMPACT_ASCII_r12] = _GUARD_NOS_COMPACT_ASCII, [_GUARD_NOS_COMPACT_ASCII_r22] = _GUARD_NOS_COMPACT_ASCII, [_GUARD_NOS_COMPACT_ASCII_r33] = _GUARD_NOS_COMPACT_ASCII, + [_GUARD_NOS_COMPACT_ASCII_r44] = _GUARD_NOS_COMPACT_ASCII, + [_GUARD_NOS_COMPACT_ASCII_r55] = _GUARD_NOS_COMPACT_ASCII, [_GUARD_NOS_UNICODE_r02] = _GUARD_NOS_UNICODE, [_GUARD_NOS_UNICODE_r12] = _GUARD_NOS_UNICODE, [_GUARD_NOS_UNICODE_r22] = _GUARD_NOS_UNICODE, [_GUARD_NOS_UNICODE_r33] = _GUARD_NOS_UNICODE, + [_GUARD_NOS_UNICODE_r44] = _GUARD_NOS_UNICODE, + [_GUARD_NOS_UNICODE_r55] = _GUARD_NOS_UNICODE, [_GUARD_TOS_UNICODE_r01] = _GUARD_TOS_UNICODE, [_GUARD_TOS_UNICODE_r11] = _GUARD_TOS_UNICODE, [_GUARD_TOS_UNICODE_r22] = _GUARD_TOS_UNICODE, [_GUARD_TOS_UNICODE_r33] = _GUARD_TOS_UNICODE, + [_GUARD_TOS_UNICODE_r44] = _GUARD_TOS_UNICODE, + [_GUARD_TOS_UNICODE_r55] = _GUARD_TOS_UNICODE, [_TO_BOOL_STR_r02] = _TO_BOOL_STR, [_TO_BOOL_STR_r12] = _TO_BOOL_STR, [_TO_BOOL_STR_r23] = _TO_BOOL_STR, + [_TO_BOOL_STR_r34] = _TO_BOOL_STR, + [_TO_BOOL_STR_r45] = _TO_BOOL_STR, [_REPLACE_WITH_TRUE_r02] = _REPLACE_WITH_TRUE, [_REPLACE_WITH_TRUE_r12] = _REPLACE_WITH_TRUE, [_REPLACE_WITH_TRUE_r23] = _REPLACE_WITH_TRUE, + [_REPLACE_WITH_TRUE_r34] = _REPLACE_WITH_TRUE, + [_REPLACE_WITH_TRUE_r45] = _REPLACE_WITH_TRUE, [_UNARY_INVERT_r12] = _UNARY_INVERT, [_GUARD_NOS_INT_r02] = _GUARD_NOS_INT, [_GUARD_NOS_INT_r12] = _GUARD_NOS_INT, [_GUARD_NOS_INT_r22] = _GUARD_NOS_INT, [_GUARD_NOS_INT_r33] = _GUARD_NOS_INT, + [_GUARD_NOS_INT_r44] = _GUARD_NOS_INT, + [_GUARD_NOS_INT_r55] = _GUARD_NOS_INT, [_GUARD_TOS_INT_r01] = _GUARD_TOS_INT, [_GUARD_TOS_INT_r11] = _GUARD_TOS_INT, [_GUARD_TOS_INT_r22] = _GUARD_TOS_INT, [_GUARD_TOS_INT_r33] = _GUARD_TOS_INT, + [_GUARD_TOS_INT_r44] = _GUARD_TOS_INT, + [_GUARD_TOS_INT_r55] = _GUARD_TOS_INT, [_GUARD_NOS_OVERFLOWED_r02] = _GUARD_NOS_OVERFLOWED, [_GUARD_NOS_OVERFLOWED_r12] = _GUARD_NOS_OVERFLOWED, [_GUARD_NOS_OVERFLOWED_r22] = _GUARD_NOS_OVERFLOWED, [_GUARD_NOS_OVERFLOWED_r33] = _GUARD_NOS_OVERFLOWED, + [_GUARD_NOS_OVERFLOWED_r44] = _GUARD_NOS_OVERFLOWED, + [_GUARD_NOS_OVERFLOWED_r55] = _GUARD_NOS_OVERFLOWED, [_GUARD_TOS_OVERFLOWED_r01] = _GUARD_TOS_OVERFLOWED, [_GUARD_TOS_OVERFLOWED_r11] = _GUARD_TOS_OVERFLOWED, [_GUARD_TOS_OVERFLOWED_r22] = _GUARD_TOS_OVERFLOWED, [_GUARD_TOS_OVERFLOWED_r33] = _GUARD_TOS_OVERFLOWED, + [_GUARD_TOS_OVERFLOWED_r44] = _GUARD_TOS_OVERFLOWED, + [_GUARD_TOS_OVERFLOWED_r55] = _GUARD_TOS_OVERFLOWED, [_BINARY_OP_MULTIPLY_INT_r03] = _BINARY_OP_MULTIPLY_INT, [_BINARY_OP_MULTIPLY_INT_r13] = _BINARY_OP_MULTIPLY_INT, [_BINARY_OP_MULTIPLY_INT_r23] = _BINARY_OP_MULTIPLY_INT, + [_BINARY_OP_MULTIPLY_INT_r34] = _BINARY_OP_MULTIPLY_INT, + [_BINARY_OP_MULTIPLY_INT_r45] = _BINARY_OP_MULTIPLY_INT, [_BINARY_OP_ADD_INT_r03] = _BINARY_OP_ADD_INT, [_BINARY_OP_ADD_INT_r13] = _BINARY_OP_ADD_INT, [_BINARY_OP_ADD_INT_r23] = _BINARY_OP_ADD_INT, + [_BINARY_OP_ADD_INT_r34] = _BINARY_OP_ADD_INT, + [_BINARY_OP_ADD_INT_r45] = _BINARY_OP_ADD_INT, [_BINARY_OP_SUBTRACT_INT_r03] = _BINARY_OP_SUBTRACT_INT, [_BINARY_OP_SUBTRACT_INT_r13] = _BINARY_OP_SUBTRACT_INT, [_BINARY_OP_SUBTRACT_INT_r23] = _BINARY_OP_SUBTRACT_INT, + [_BINARY_OP_SUBTRACT_INT_r34] = _BINARY_OP_SUBTRACT_INT, + [_BINARY_OP_SUBTRACT_INT_r45] = _BINARY_OP_SUBTRACT_INT, [_GUARD_NOS_FLOAT_r02] = _GUARD_NOS_FLOAT, [_GUARD_NOS_FLOAT_r12] = _GUARD_NOS_FLOAT, [_GUARD_NOS_FLOAT_r22] = _GUARD_NOS_FLOAT, [_GUARD_NOS_FLOAT_r33] = _GUARD_NOS_FLOAT, + [_GUARD_NOS_FLOAT_r44] = _GUARD_NOS_FLOAT, + [_GUARD_NOS_FLOAT_r55] = _GUARD_NOS_FLOAT, [_GUARD_TOS_FLOAT_r01] = _GUARD_TOS_FLOAT, [_GUARD_TOS_FLOAT_r11] = _GUARD_TOS_FLOAT, [_GUARD_TOS_FLOAT_r22] = _GUARD_TOS_FLOAT, [_GUARD_TOS_FLOAT_r33] = _GUARD_TOS_FLOAT, + [_GUARD_TOS_FLOAT_r44] = _GUARD_TOS_FLOAT, + [_GUARD_TOS_FLOAT_r55] = _GUARD_TOS_FLOAT, [_BINARY_OP_MULTIPLY_FLOAT_r03] = _BINARY_OP_MULTIPLY_FLOAT, [_BINARY_OP_MULTIPLY_FLOAT_r13] = _BINARY_OP_MULTIPLY_FLOAT, [_BINARY_OP_MULTIPLY_FLOAT_r23] = _BINARY_OP_MULTIPLY_FLOAT, + [_BINARY_OP_MULTIPLY_FLOAT_r34] = _BINARY_OP_MULTIPLY_FLOAT, + [_BINARY_OP_MULTIPLY_FLOAT_r45] = _BINARY_OP_MULTIPLY_FLOAT, [_BINARY_OP_ADD_FLOAT_r03] = _BINARY_OP_ADD_FLOAT, [_BINARY_OP_ADD_FLOAT_r13] = _BINARY_OP_ADD_FLOAT, [_BINARY_OP_ADD_FLOAT_r23] = _BINARY_OP_ADD_FLOAT, + [_BINARY_OP_ADD_FLOAT_r34] = _BINARY_OP_ADD_FLOAT, + [_BINARY_OP_ADD_FLOAT_r45] = _BINARY_OP_ADD_FLOAT, [_BINARY_OP_SUBTRACT_FLOAT_r03] = _BINARY_OP_SUBTRACT_FLOAT, [_BINARY_OP_SUBTRACT_FLOAT_r13] = _BINARY_OP_SUBTRACT_FLOAT, [_BINARY_OP_SUBTRACT_FLOAT_r23] = _BINARY_OP_SUBTRACT_FLOAT, + [_BINARY_OP_SUBTRACT_FLOAT_r34] = _BINARY_OP_SUBTRACT_FLOAT, + [_BINARY_OP_SUBTRACT_FLOAT_r45] = _BINARY_OP_SUBTRACT_FLOAT, [_BINARY_OP_ADD_UNICODE_r03] = _BINARY_OP_ADD_UNICODE, [_BINARY_OP_ADD_UNICODE_r13] = _BINARY_OP_ADD_UNICODE, [_BINARY_OP_ADD_UNICODE_r23] = _BINARY_OP_ADD_UNICODE, + [_BINARY_OP_ADD_UNICODE_r34] = _BINARY_OP_ADD_UNICODE, + [_BINARY_OP_ADD_UNICODE_r45] = _BINARY_OP_ADD_UNICODE, [_BINARY_OP_INPLACE_ADD_UNICODE_r21] = _BINARY_OP_INPLACE_ADD_UNICODE, [_GUARD_BINARY_OP_EXTEND_r22] = _GUARD_BINARY_OP_EXTEND, [_BINARY_OP_EXTEND_r23] = _BINARY_OP_EXTEND, [_BINARY_SLICE_r31] = _BINARY_SLICE, - [_STORE_SLICE_r30] = _STORE_SLICE, + [_STORE_SLICE_r40] = _STORE_SLICE, [_BINARY_OP_SUBSCR_LIST_INT_r23] = _BINARY_OP_SUBSCR_LIST_INT, [_BINARY_OP_SUBSCR_LIST_SLICE_r23] = _BINARY_OP_SUBSCR_LIST_SLICE, [_BINARY_OP_SUBSCR_STR_INT_r23] = _BINARY_OP_SUBSCR_STR_INT, @@ -3759,43 +3894,63 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_GUARD_NOS_TUPLE_r12] = _GUARD_NOS_TUPLE, [_GUARD_NOS_TUPLE_r22] = _GUARD_NOS_TUPLE, [_GUARD_NOS_TUPLE_r33] = _GUARD_NOS_TUPLE, + [_GUARD_NOS_TUPLE_r44] = _GUARD_NOS_TUPLE, + [_GUARD_NOS_TUPLE_r55] = _GUARD_NOS_TUPLE, [_GUARD_TOS_TUPLE_r01] = _GUARD_TOS_TUPLE, [_GUARD_TOS_TUPLE_r11] = _GUARD_TOS_TUPLE, [_GUARD_TOS_TUPLE_r22] = _GUARD_TOS_TUPLE, [_GUARD_TOS_TUPLE_r33] = _GUARD_TOS_TUPLE, + [_GUARD_TOS_TUPLE_r44] = _GUARD_TOS_TUPLE, + [_GUARD_TOS_TUPLE_r55] = _GUARD_TOS_TUPLE, [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02] = _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS, [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12] = _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS, [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22] = _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS, [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33] = _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS, + [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r44] = _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS, + [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r55] = _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS, [_BINARY_OP_SUBSCR_TUPLE_INT_r03] = _BINARY_OP_SUBSCR_TUPLE_INT, [_BINARY_OP_SUBSCR_TUPLE_INT_r13] = _BINARY_OP_SUBSCR_TUPLE_INT, [_BINARY_OP_SUBSCR_TUPLE_INT_r23] = _BINARY_OP_SUBSCR_TUPLE_INT, + [_BINARY_OP_SUBSCR_TUPLE_INT_r34] = _BINARY_OP_SUBSCR_TUPLE_INT, + [_BINARY_OP_SUBSCR_TUPLE_INT_r45] = _BINARY_OP_SUBSCR_TUPLE_INT, [_GUARD_NOS_DICT_r02] = _GUARD_NOS_DICT, [_GUARD_NOS_DICT_r12] = _GUARD_NOS_DICT, [_GUARD_NOS_DICT_r22] = _GUARD_NOS_DICT, [_GUARD_NOS_DICT_r33] = _GUARD_NOS_DICT, + [_GUARD_NOS_DICT_r44] = _GUARD_NOS_DICT, + [_GUARD_NOS_DICT_r55] = _GUARD_NOS_DICT, [_GUARD_NOS_ANY_DICT_r02] = _GUARD_NOS_ANY_DICT, [_GUARD_NOS_ANY_DICT_r12] = _GUARD_NOS_ANY_DICT, [_GUARD_NOS_ANY_DICT_r22] = _GUARD_NOS_ANY_DICT, [_GUARD_NOS_ANY_DICT_r33] = _GUARD_NOS_ANY_DICT, + [_GUARD_NOS_ANY_DICT_r44] = _GUARD_NOS_ANY_DICT, + [_GUARD_NOS_ANY_DICT_r55] = _GUARD_NOS_ANY_DICT, [_GUARD_TOS_ANY_DICT_r01] = _GUARD_TOS_ANY_DICT, [_GUARD_TOS_ANY_DICT_r11] = _GUARD_TOS_ANY_DICT, [_GUARD_TOS_ANY_DICT_r22] = _GUARD_TOS_ANY_DICT, [_GUARD_TOS_ANY_DICT_r33] = _GUARD_TOS_ANY_DICT, + [_GUARD_TOS_ANY_DICT_r44] = _GUARD_TOS_ANY_DICT, + [_GUARD_TOS_ANY_DICT_r55] = _GUARD_TOS_ANY_DICT, [_GUARD_TOS_DICT_r01] = _GUARD_TOS_DICT, [_GUARD_TOS_DICT_r11] = _GUARD_TOS_DICT, [_GUARD_TOS_DICT_r22] = _GUARD_TOS_DICT, [_GUARD_TOS_DICT_r33] = _GUARD_TOS_DICT, + [_GUARD_TOS_DICT_r44] = _GUARD_TOS_DICT, + [_GUARD_TOS_DICT_r55] = _GUARD_TOS_DICT, [_GUARD_TOS_FROZENDICT_r01] = _GUARD_TOS_FROZENDICT, [_GUARD_TOS_FROZENDICT_r11] = _GUARD_TOS_FROZENDICT, [_GUARD_TOS_FROZENDICT_r22] = _GUARD_TOS_FROZENDICT, [_GUARD_TOS_FROZENDICT_r33] = _GUARD_TOS_FROZENDICT, + [_GUARD_TOS_FROZENDICT_r44] = _GUARD_TOS_FROZENDICT, + [_GUARD_TOS_FROZENDICT_r55] = _GUARD_TOS_FROZENDICT, [_BINARY_OP_SUBSCR_DICT_r23] = _BINARY_OP_SUBSCR_DICT, [_BINARY_OP_SUBSCR_CHECK_FUNC_r23] = _BINARY_OP_SUBSCR_CHECK_FUNC, [_BINARY_OP_SUBSCR_INIT_CALL_r01] = _BINARY_OP_SUBSCR_INIT_CALL, [_BINARY_OP_SUBSCR_INIT_CALL_r11] = _BINARY_OP_SUBSCR_INIT_CALL, [_BINARY_OP_SUBSCR_INIT_CALL_r21] = _BINARY_OP_SUBSCR_INIT_CALL, [_BINARY_OP_SUBSCR_INIT_CALL_r31] = _BINARY_OP_SUBSCR_INIT_CALL, + [_BINARY_OP_SUBSCR_INIT_CALL_r42] = _BINARY_OP_SUBSCR_INIT_CALL, + [_BINARY_OP_SUBSCR_INIT_CALL_r53] = _BINARY_OP_SUBSCR_INIT_CALL, [_LIST_APPEND_r10] = _LIST_APPEND, [_SET_ADD_r10] = _SET_ADD, [_STORE_SUBSCR_r30] = _STORE_SUBSCR, @@ -3814,6 +3969,8 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_LOAD_COMMON_CONSTANT_r01] = _LOAD_COMMON_CONSTANT, [_LOAD_COMMON_CONSTANT_r12] = _LOAD_COMMON_CONSTANT, [_LOAD_COMMON_CONSTANT_r23] = _LOAD_COMMON_CONSTANT, + [_LOAD_COMMON_CONSTANT_r34] = _LOAD_COMMON_CONSTANT, + [_LOAD_COMMON_CONSTANT_r45] = _LOAD_COMMON_CONSTANT, [_LOAD_BUILD_CLASS_r01] = _LOAD_BUILD_CLASS, [_STORE_NAME_r10] = _STORE_NAME, [_DELETE_NAME_r00] = _DELETE_NAME, @@ -3829,6 +3986,8 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_LOAD_LOCALS_r01] = _LOAD_LOCALS, [_LOAD_LOCALS_r12] = _LOAD_LOCALS, [_LOAD_LOCALS_r23] = _LOAD_LOCALS, + [_LOAD_LOCALS_r34] = _LOAD_LOCALS, + [_LOAD_LOCALS_r45] = _LOAD_LOCALS, [_LOAD_NAME_r01] = _LOAD_NAME, [_LOAD_GLOBAL_r00] = _LOAD_GLOBAL, [_PUSH_NULL_CONDITIONAL_r00] = _PUSH_NULL_CONDITIONAL, @@ -3836,6 +3995,8 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_GUARD_GLOBALS_VERSION_r11] = _GUARD_GLOBALS_VERSION, [_GUARD_GLOBALS_VERSION_r22] = _GUARD_GLOBALS_VERSION, [_GUARD_GLOBALS_VERSION_r33] = _GUARD_GLOBALS_VERSION, + [_GUARD_GLOBALS_VERSION_r44] = _GUARD_GLOBALS_VERSION, + [_GUARD_GLOBALS_VERSION_r55] = _GUARD_GLOBALS_VERSION, [_LOAD_GLOBAL_MODULE_r01] = _LOAD_GLOBAL_MODULE, [_LOAD_GLOBAL_BUILTINS_r01] = _LOAD_GLOBAL_BUILTINS, [_DELETE_FAST_r00] = _DELETE_FAST, @@ -3848,6 +4009,8 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_COPY_FREE_VARS_r11] = _COPY_FREE_VARS, [_COPY_FREE_VARS_r22] = _COPY_FREE_VARS, [_COPY_FREE_VARS_r33] = _COPY_FREE_VARS, + [_COPY_FREE_VARS_r44] = _COPY_FREE_VARS, + [_COPY_FREE_VARS_r55] = _COPY_FREE_VARS, [_BUILD_STRING_r01] = _BUILD_STRING, [_BUILD_INTERPOLATION_r01] = _BUILD_INTERPOLATION, [_BUILD_TEMPLATE_r21] = _BUILD_TEMPLATE, @@ -3868,32 +4031,46 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_GUARD_TYPE_VERSION_r11] = _GUARD_TYPE_VERSION, [_GUARD_TYPE_VERSION_r22] = _GUARD_TYPE_VERSION, [_GUARD_TYPE_VERSION_r33] = _GUARD_TYPE_VERSION, + [_GUARD_TYPE_VERSION_r44] = _GUARD_TYPE_VERSION, + [_GUARD_TYPE_VERSION_r55] = _GUARD_TYPE_VERSION, [_GUARD_TYPE_VERSION_AND_LOCK_r01] = _GUARD_TYPE_VERSION_AND_LOCK, [_GUARD_TYPE_VERSION_AND_LOCK_r11] = _GUARD_TYPE_VERSION_AND_LOCK, [_GUARD_TYPE_VERSION_AND_LOCK_r22] = _GUARD_TYPE_VERSION_AND_LOCK, [_GUARD_TYPE_VERSION_AND_LOCK_r33] = _GUARD_TYPE_VERSION_AND_LOCK, + [_GUARD_TYPE_VERSION_AND_LOCK_r44] = _GUARD_TYPE_VERSION_AND_LOCK, + [_GUARD_TYPE_VERSION_AND_LOCK_r55] = _GUARD_TYPE_VERSION_AND_LOCK, [_CHECK_MANAGED_OBJECT_HAS_VALUES_r01] = _CHECK_MANAGED_OBJECT_HAS_VALUES, [_CHECK_MANAGED_OBJECT_HAS_VALUES_r11] = _CHECK_MANAGED_OBJECT_HAS_VALUES, [_CHECK_MANAGED_OBJECT_HAS_VALUES_r22] = _CHECK_MANAGED_OBJECT_HAS_VALUES, [_CHECK_MANAGED_OBJECT_HAS_VALUES_r33] = _CHECK_MANAGED_OBJECT_HAS_VALUES, + [_CHECK_MANAGED_OBJECT_HAS_VALUES_r44] = _CHECK_MANAGED_OBJECT_HAS_VALUES, + [_CHECK_MANAGED_OBJECT_HAS_VALUES_r55] = _CHECK_MANAGED_OBJECT_HAS_VALUES, [_LOAD_ATTR_INSTANCE_VALUE_r02] = _LOAD_ATTR_INSTANCE_VALUE, [_LOAD_ATTR_INSTANCE_VALUE_r12] = _LOAD_ATTR_INSTANCE_VALUE, [_LOAD_ATTR_INSTANCE_VALUE_r23] = _LOAD_ATTR_INSTANCE_VALUE, + [_LOAD_ATTR_INSTANCE_VALUE_r34] = _LOAD_ATTR_INSTANCE_VALUE, + [_LOAD_ATTR_INSTANCE_VALUE_r45] = _LOAD_ATTR_INSTANCE_VALUE, [_LOAD_ATTR_MODULE_r12] = _LOAD_ATTR_MODULE, [_LOAD_ATTR_WITH_HINT_r12] = _LOAD_ATTR_WITH_HINT, [_LOAD_ATTR_SLOT_r02] = _LOAD_ATTR_SLOT, [_LOAD_ATTR_SLOT_r12] = _LOAD_ATTR_SLOT, [_LOAD_ATTR_SLOT_r23] = _LOAD_ATTR_SLOT, + [_LOAD_ATTR_SLOT_r34] = _LOAD_ATTR_SLOT, + [_LOAD_ATTR_SLOT_r45] = _LOAD_ATTR_SLOT, [_CHECK_ATTR_CLASS_r01] = _CHECK_ATTR_CLASS, [_CHECK_ATTR_CLASS_r11] = _CHECK_ATTR_CLASS, [_CHECK_ATTR_CLASS_r22] = _CHECK_ATTR_CLASS, [_CHECK_ATTR_CLASS_r33] = _CHECK_ATTR_CLASS, + [_CHECK_ATTR_CLASS_r44] = _CHECK_ATTR_CLASS, + [_CHECK_ATTR_CLASS_r55] = _CHECK_ATTR_CLASS, [_LOAD_ATTR_CLASS_r11] = _LOAD_ATTR_CLASS, [_LOAD_ATTR_PROPERTY_FRAME_r11] = _LOAD_ATTR_PROPERTY_FRAME, [_GUARD_DORV_NO_DICT_r01] = _GUARD_DORV_NO_DICT, [_GUARD_DORV_NO_DICT_r11] = _GUARD_DORV_NO_DICT, [_GUARD_DORV_NO_DICT_r22] = _GUARD_DORV_NO_DICT, [_GUARD_DORV_NO_DICT_r33] = _GUARD_DORV_NO_DICT, + [_GUARD_DORV_NO_DICT_r44] = _GUARD_DORV_NO_DICT, + [_GUARD_DORV_NO_DICT_r55] = _GUARD_DORV_NO_DICT, [_STORE_ATTR_INSTANCE_VALUE_r21] = _STORE_ATTR_INSTANCE_VALUE, [_STORE_ATTR_WITH_HINT_r21] = _STORE_ATTR_WITH_HINT, [_STORE_ATTR_SLOT_r21] = _STORE_ATTR_SLOT, @@ -3901,24 +4078,34 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_COMPARE_OP_FLOAT_r03] = _COMPARE_OP_FLOAT, [_COMPARE_OP_FLOAT_r13] = _COMPARE_OP_FLOAT, [_COMPARE_OP_FLOAT_r23] = _COMPARE_OP_FLOAT, + [_COMPARE_OP_FLOAT_r34] = _COMPARE_OP_FLOAT, + [_COMPARE_OP_FLOAT_r45] = _COMPARE_OP_FLOAT, [_COMPARE_OP_INT_r23] = _COMPARE_OP_INT, [_COMPARE_OP_STR_r23] = _COMPARE_OP_STR, [_IS_OP_r03] = _IS_OP, [_IS_OP_r13] = _IS_OP, [_IS_OP_r23] = _IS_OP, + [_IS_OP_r34] = _IS_OP, + [_IS_OP_r45] = _IS_OP, [_CONTAINS_OP_r23] = _CONTAINS_OP, [_GUARD_TOS_ANY_SET_r01] = _GUARD_TOS_ANY_SET, [_GUARD_TOS_ANY_SET_r11] = _GUARD_TOS_ANY_SET, [_GUARD_TOS_ANY_SET_r22] = _GUARD_TOS_ANY_SET, [_GUARD_TOS_ANY_SET_r33] = _GUARD_TOS_ANY_SET, + [_GUARD_TOS_ANY_SET_r44] = _GUARD_TOS_ANY_SET, + [_GUARD_TOS_ANY_SET_r55] = _GUARD_TOS_ANY_SET, [_GUARD_TOS_SET_r01] = _GUARD_TOS_SET, [_GUARD_TOS_SET_r11] = _GUARD_TOS_SET, [_GUARD_TOS_SET_r22] = _GUARD_TOS_SET, [_GUARD_TOS_SET_r33] = _GUARD_TOS_SET, + [_GUARD_TOS_SET_r44] = _GUARD_TOS_SET, + [_GUARD_TOS_SET_r55] = _GUARD_TOS_SET, [_GUARD_TOS_FROZENSET_r01] = _GUARD_TOS_FROZENSET, [_GUARD_TOS_FROZENSET_r11] = _GUARD_TOS_FROZENSET, [_GUARD_TOS_FROZENSET_r22] = _GUARD_TOS_FROZENSET, [_GUARD_TOS_FROZENSET_r33] = _GUARD_TOS_FROZENSET, + [_GUARD_TOS_FROZENSET_r44] = _GUARD_TOS_FROZENSET, + [_GUARD_TOS_FROZENSET_r55] = _GUARD_TOS_FROZENSET, [_CONTAINS_OP_SET_r23] = _CONTAINS_OP_SET, [_CONTAINS_OP_DICT_r23] = _CONTAINS_OP_DICT, [_CHECK_EG_MATCH_r22] = _CHECK_EG_MATCH, @@ -3931,9 +4118,13 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_MATCH_MAPPING_r02] = _MATCH_MAPPING, [_MATCH_MAPPING_r12] = _MATCH_MAPPING, [_MATCH_MAPPING_r23] = _MATCH_MAPPING, + [_MATCH_MAPPING_r34] = _MATCH_MAPPING, + [_MATCH_MAPPING_r45] = _MATCH_MAPPING, [_MATCH_SEQUENCE_r02] = _MATCH_SEQUENCE, [_MATCH_SEQUENCE_r12] = _MATCH_SEQUENCE, [_MATCH_SEQUENCE_r23] = _MATCH_SEQUENCE, + [_MATCH_SEQUENCE_r34] = _MATCH_SEQUENCE, + [_MATCH_SEQUENCE_r45] = _MATCH_SEQUENCE, [_MATCH_KEYS_r23] = _MATCH_KEYS, [_GET_ITER_r12] = _GET_ITER, [_GET_YIELD_FROM_ITER_r11] = _GET_YIELD_FROM_ITER, @@ -3942,65 +4133,97 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_ITER_CHECK_LIST_r12] = _ITER_CHECK_LIST, [_ITER_CHECK_LIST_r22] = _ITER_CHECK_LIST, [_ITER_CHECK_LIST_r33] = _ITER_CHECK_LIST, + [_ITER_CHECK_LIST_r44] = _ITER_CHECK_LIST, + [_ITER_CHECK_LIST_r55] = _ITER_CHECK_LIST, [_GUARD_NOT_EXHAUSTED_LIST_r02] = _GUARD_NOT_EXHAUSTED_LIST, [_GUARD_NOT_EXHAUSTED_LIST_r12] = _GUARD_NOT_EXHAUSTED_LIST, [_GUARD_NOT_EXHAUSTED_LIST_r22] = _GUARD_NOT_EXHAUSTED_LIST, [_GUARD_NOT_EXHAUSTED_LIST_r33] = _GUARD_NOT_EXHAUSTED_LIST, + [_GUARD_NOT_EXHAUSTED_LIST_r44] = _GUARD_NOT_EXHAUSTED_LIST, + [_GUARD_NOT_EXHAUSTED_LIST_r55] = _GUARD_NOT_EXHAUSTED_LIST, [_ITER_NEXT_LIST_TIER_TWO_r23] = _ITER_NEXT_LIST_TIER_TWO, [_ITER_CHECK_TUPLE_r02] = _ITER_CHECK_TUPLE, [_ITER_CHECK_TUPLE_r12] = _ITER_CHECK_TUPLE, [_ITER_CHECK_TUPLE_r22] = _ITER_CHECK_TUPLE, [_ITER_CHECK_TUPLE_r33] = _ITER_CHECK_TUPLE, + [_ITER_CHECK_TUPLE_r44] = _ITER_CHECK_TUPLE, + [_ITER_CHECK_TUPLE_r55] = _ITER_CHECK_TUPLE, [_GUARD_NOT_EXHAUSTED_TUPLE_r02] = _GUARD_NOT_EXHAUSTED_TUPLE, [_GUARD_NOT_EXHAUSTED_TUPLE_r12] = _GUARD_NOT_EXHAUSTED_TUPLE, [_GUARD_NOT_EXHAUSTED_TUPLE_r22] = _GUARD_NOT_EXHAUSTED_TUPLE, [_GUARD_NOT_EXHAUSTED_TUPLE_r33] = _GUARD_NOT_EXHAUSTED_TUPLE, + [_GUARD_NOT_EXHAUSTED_TUPLE_r44] = _GUARD_NOT_EXHAUSTED_TUPLE, + [_GUARD_NOT_EXHAUSTED_TUPLE_r55] = _GUARD_NOT_EXHAUSTED_TUPLE, [_ITER_NEXT_TUPLE_r03] = _ITER_NEXT_TUPLE, [_ITER_NEXT_TUPLE_r13] = _ITER_NEXT_TUPLE, [_ITER_NEXT_TUPLE_r23] = _ITER_NEXT_TUPLE, + [_ITER_NEXT_TUPLE_r34] = _ITER_NEXT_TUPLE, + [_ITER_NEXT_TUPLE_r45] = _ITER_NEXT_TUPLE, [_ITER_CHECK_RANGE_r02] = _ITER_CHECK_RANGE, [_ITER_CHECK_RANGE_r12] = _ITER_CHECK_RANGE, [_ITER_CHECK_RANGE_r22] = _ITER_CHECK_RANGE, [_ITER_CHECK_RANGE_r33] = _ITER_CHECK_RANGE, + [_ITER_CHECK_RANGE_r44] = _ITER_CHECK_RANGE, + [_ITER_CHECK_RANGE_r55] = _ITER_CHECK_RANGE, [_GUARD_NOT_EXHAUSTED_RANGE_r02] = _GUARD_NOT_EXHAUSTED_RANGE, [_GUARD_NOT_EXHAUSTED_RANGE_r12] = _GUARD_NOT_EXHAUSTED_RANGE, [_GUARD_NOT_EXHAUSTED_RANGE_r22] = _GUARD_NOT_EXHAUSTED_RANGE, [_GUARD_NOT_EXHAUSTED_RANGE_r33] = _GUARD_NOT_EXHAUSTED_RANGE, + [_GUARD_NOT_EXHAUSTED_RANGE_r44] = _GUARD_NOT_EXHAUSTED_RANGE, + [_GUARD_NOT_EXHAUSTED_RANGE_r55] = _GUARD_NOT_EXHAUSTED_RANGE, [_ITER_NEXT_RANGE_r03] = _ITER_NEXT_RANGE, [_ITER_NEXT_RANGE_r13] = _ITER_NEXT_RANGE, [_ITER_NEXT_RANGE_r23] = _ITER_NEXT_RANGE, + [_ITER_NEXT_RANGE_r34] = _ITER_NEXT_RANGE, + [_ITER_NEXT_RANGE_r45] = _ITER_NEXT_RANGE, [_FOR_ITER_GEN_FRAME_r03] = _FOR_ITER_GEN_FRAME, [_FOR_ITER_GEN_FRAME_r13] = _FOR_ITER_GEN_FRAME, [_FOR_ITER_GEN_FRAME_r23] = _FOR_ITER_GEN_FRAME, + [_FOR_ITER_GEN_FRAME_r34] = _FOR_ITER_GEN_FRAME, + [_FOR_ITER_GEN_FRAME_r45] = _FOR_ITER_GEN_FRAME, [_INSERT_NULL_r10] = _INSERT_NULL, [_LOAD_SPECIAL_r00] = _LOAD_SPECIAL, - [_WITH_EXCEPT_START_r33] = _WITH_EXCEPT_START, + [_WITH_EXCEPT_START_r55] = _WITH_EXCEPT_START, [_PUSH_EXC_INFO_r02] = _PUSH_EXC_INFO, [_PUSH_EXC_INFO_r12] = _PUSH_EXC_INFO, [_PUSH_EXC_INFO_r23] = _PUSH_EXC_INFO, + [_PUSH_EXC_INFO_r34] = _PUSH_EXC_INFO, + [_PUSH_EXC_INFO_r45] = _PUSH_EXC_INFO, [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01] = _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11] = _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22] = _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33] = _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, + [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r44] = _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, + [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r55] = _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, [_GUARD_KEYS_VERSION_r01] = _GUARD_KEYS_VERSION, [_GUARD_KEYS_VERSION_r11] = _GUARD_KEYS_VERSION, [_GUARD_KEYS_VERSION_r22] = _GUARD_KEYS_VERSION, [_GUARD_KEYS_VERSION_r33] = _GUARD_KEYS_VERSION, + [_GUARD_KEYS_VERSION_r44] = _GUARD_KEYS_VERSION, + [_GUARD_KEYS_VERSION_r55] = _GUARD_KEYS_VERSION, [_LOAD_ATTR_METHOD_WITH_VALUES_r02] = _LOAD_ATTR_METHOD_WITH_VALUES, [_LOAD_ATTR_METHOD_WITH_VALUES_r12] = _LOAD_ATTR_METHOD_WITH_VALUES, [_LOAD_ATTR_METHOD_WITH_VALUES_r23] = _LOAD_ATTR_METHOD_WITH_VALUES, + [_LOAD_ATTR_METHOD_WITH_VALUES_r34] = _LOAD_ATTR_METHOD_WITH_VALUES, + [_LOAD_ATTR_METHOD_WITH_VALUES_r45] = _LOAD_ATTR_METHOD_WITH_VALUES, [_LOAD_ATTR_METHOD_NO_DICT_r02] = _LOAD_ATTR_METHOD_NO_DICT, [_LOAD_ATTR_METHOD_NO_DICT_r12] = _LOAD_ATTR_METHOD_NO_DICT, [_LOAD_ATTR_METHOD_NO_DICT_r23] = _LOAD_ATTR_METHOD_NO_DICT, + [_LOAD_ATTR_METHOD_NO_DICT_r34] = _LOAD_ATTR_METHOD_NO_DICT, + [_LOAD_ATTR_METHOD_NO_DICT_r45] = _LOAD_ATTR_METHOD_NO_DICT, [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11] = _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES, [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11] = _LOAD_ATTR_NONDESCRIPTOR_NO_DICT, [_CHECK_ATTR_METHOD_LAZY_DICT_r01] = _CHECK_ATTR_METHOD_LAZY_DICT, [_CHECK_ATTR_METHOD_LAZY_DICT_r11] = _CHECK_ATTR_METHOD_LAZY_DICT, [_CHECK_ATTR_METHOD_LAZY_DICT_r22] = _CHECK_ATTR_METHOD_LAZY_DICT, [_CHECK_ATTR_METHOD_LAZY_DICT_r33] = _CHECK_ATTR_METHOD_LAZY_DICT, + [_CHECK_ATTR_METHOD_LAZY_DICT_r44] = _CHECK_ATTR_METHOD_LAZY_DICT, + [_CHECK_ATTR_METHOD_LAZY_DICT_r55] = _CHECK_ATTR_METHOD_LAZY_DICT, [_LOAD_ATTR_METHOD_LAZY_DICT_r02] = _LOAD_ATTR_METHOD_LAZY_DICT, [_LOAD_ATTR_METHOD_LAZY_DICT_r12] = _LOAD_ATTR_METHOD_LAZY_DICT, [_LOAD_ATTR_METHOD_LAZY_DICT_r23] = _LOAD_ATTR_METHOD_LAZY_DICT, + [_LOAD_ATTR_METHOD_LAZY_DICT_r34] = _LOAD_ATTR_METHOD_LAZY_DICT, + [_LOAD_ATTR_METHOD_LAZY_DICT_r45] = _LOAD_ATTR_METHOD_LAZY_DICT, [_MAYBE_EXPAND_METHOD_r00] = _MAYBE_EXPAND_METHOD, [_PY_FRAME_GENERAL_r01] = _PY_FRAME_GENERAL, [_CHECK_FUNCTION_VERSION_r00] = _CHECK_FUNCTION_VERSION, @@ -4008,6 +4231,8 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_CHECK_FUNCTION_VERSION_INLINE_r11] = _CHECK_FUNCTION_VERSION_INLINE, [_CHECK_FUNCTION_VERSION_INLINE_r22] = _CHECK_FUNCTION_VERSION_INLINE, [_CHECK_FUNCTION_VERSION_INLINE_r33] = _CHECK_FUNCTION_VERSION_INLINE, + [_CHECK_FUNCTION_VERSION_INLINE_r44] = _CHECK_FUNCTION_VERSION_INLINE, + [_CHECK_FUNCTION_VERSION_INLINE_r55] = _CHECK_FUNCTION_VERSION_INLINE, [_CHECK_METHOD_VERSION_r00] = _CHECK_METHOD_VERSION, [_EXPAND_METHOD_r00] = _EXPAND_METHOD, [_CHECK_IS_NOT_PY_CALLABLE_r00] = _CHECK_IS_NOT_PY_CALLABLE, @@ -4018,12 +4243,16 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_CHECK_PEP_523_r11] = _CHECK_PEP_523, [_CHECK_PEP_523_r22] = _CHECK_PEP_523, [_CHECK_PEP_523_r33] = _CHECK_PEP_523, + [_CHECK_PEP_523_r44] = _CHECK_PEP_523, + [_CHECK_PEP_523_r55] = _CHECK_PEP_523, [_CHECK_FUNCTION_EXACT_ARGS_r00] = _CHECK_FUNCTION_EXACT_ARGS, [_CHECK_STACK_SPACE_r00] = _CHECK_STACK_SPACE, [_CHECK_RECURSION_REMAINING_r00] = _CHECK_RECURSION_REMAINING, [_CHECK_RECURSION_REMAINING_r11] = _CHECK_RECURSION_REMAINING, [_CHECK_RECURSION_REMAINING_r22] = _CHECK_RECURSION_REMAINING, [_CHECK_RECURSION_REMAINING_r33] = _CHECK_RECURSION_REMAINING, + [_CHECK_RECURSION_REMAINING_r44] = _CHECK_RECURSION_REMAINING, + [_CHECK_RECURSION_REMAINING_r55] = _CHECK_RECURSION_REMAINING, [_INIT_CALL_PY_EXACT_ARGS_0_r01] = _INIT_CALL_PY_EXACT_ARGS_0, [_INIT_CALL_PY_EXACT_ARGS_1_r01] = _INIT_CALL_PY_EXACT_ARGS_1, [_INIT_CALL_PY_EXACT_ARGS_2_r01] = _INIT_CALL_PY_EXACT_ARGS_2, @@ -4035,31 +4264,45 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_GUARD_NOS_NULL_r12] = _GUARD_NOS_NULL, [_GUARD_NOS_NULL_r22] = _GUARD_NOS_NULL, [_GUARD_NOS_NULL_r33] = _GUARD_NOS_NULL, + [_GUARD_NOS_NULL_r44] = _GUARD_NOS_NULL, + [_GUARD_NOS_NULL_r55] = _GUARD_NOS_NULL, [_GUARD_NOS_NOT_NULL_r02] = _GUARD_NOS_NOT_NULL, [_GUARD_NOS_NOT_NULL_r12] = _GUARD_NOS_NOT_NULL, [_GUARD_NOS_NOT_NULL_r22] = _GUARD_NOS_NOT_NULL, [_GUARD_NOS_NOT_NULL_r33] = _GUARD_NOS_NOT_NULL, + [_GUARD_NOS_NOT_NULL_r44] = _GUARD_NOS_NOT_NULL, + [_GUARD_NOS_NOT_NULL_r55] = _GUARD_NOS_NOT_NULL, [_GUARD_THIRD_NULL_r03] = _GUARD_THIRD_NULL, [_GUARD_THIRD_NULL_r13] = _GUARD_THIRD_NULL, [_GUARD_THIRD_NULL_r23] = _GUARD_THIRD_NULL, [_GUARD_THIRD_NULL_r33] = _GUARD_THIRD_NULL, + [_GUARD_THIRD_NULL_r44] = _GUARD_THIRD_NULL, + [_GUARD_THIRD_NULL_r55] = _GUARD_THIRD_NULL, [_GUARD_CALLABLE_TYPE_1_r03] = _GUARD_CALLABLE_TYPE_1, [_GUARD_CALLABLE_TYPE_1_r13] = _GUARD_CALLABLE_TYPE_1, [_GUARD_CALLABLE_TYPE_1_r23] = _GUARD_CALLABLE_TYPE_1, [_GUARD_CALLABLE_TYPE_1_r33] = _GUARD_CALLABLE_TYPE_1, + [_GUARD_CALLABLE_TYPE_1_r44] = _GUARD_CALLABLE_TYPE_1, + [_GUARD_CALLABLE_TYPE_1_r55] = _GUARD_CALLABLE_TYPE_1, [_CALL_TYPE_1_r02] = _CALL_TYPE_1, [_CALL_TYPE_1_r12] = _CALL_TYPE_1, [_CALL_TYPE_1_r22] = _CALL_TYPE_1, [_CALL_TYPE_1_r32] = _CALL_TYPE_1, + [_CALL_TYPE_1_r43] = _CALL_TYPE_1, + [_CALL_TYPE_1_r54] = _CALL_TYPE_1, [_GUARD_CALLABLE_STR_1_r03] = _GUARD_CALLABLE_STR_1, [_GUARD_CALLABLE_STR_1_r13] = _GUARD_CALLABLE_STR_1, [_GUARD_CALLABLE_STR_1_r23] = _GUARD_CALLABLE_STR_1, [_GUARD_CALLABLE_STR_1_r33] = _GUARD_CALLABLE_STR_1, + [_GUARD_CALLABLE_STR_1_r44] = _GUARD_CALLABLE_STR_1, + [_GUARD_CALLABLE_STR_1_r55] = _GUARD_CALLABLE_STR_1, [_CALL_STR_1_r32] = _CALL_STR_1, [_GUARD_CALLABLE_TUPLE_1_r03] = _GUARD_CALLABLE_TUPLE_1, [_GUARD_CALLABLE_TUPLE_1_r13] = _GUARD_CALLABLE_TUPLE_1, [_GUARD_CALLABLE_TUPLE_1_r23] = _GUARD_CALLABLE_TUPLE_1, [_GUARD_CALLABLE_TUPLE_1_r33] = _GUARD_CALLABLE_TUPLE_1, + [_GUARD_CALLABLE_TUPLE_1_r44] = _GUARD_CALLABLE_TUPLE_1, + [_GUARD_CALLABLE_TUPLE_1_r55] = _GUARD_CALLABLE_TUPLE_1, [_CALL_TUPLE_1_r32] = _CALL_TUPLE_1, [_CHECK_AND_ALLOCATE_OBJECT_r00] = _CHECK_AND_ALLOCATE_OBJECT, [_CREATE_INIT_FRAME_r01] = _CREATE_INIT_FRAME, @@ -4072,21 +4315,29 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_GUARD_CALLABLE_LEN_r13] = _GUARD_CALLABLE_LEN, [_GUARD_CALLABLE_LEN_r23] = _GUARD_CALLABLE_LEN, [_GUARD_CALLABLE_LEN_r33] = _GUARD_CALLABLE_LEN, + [_GUARD_CALLABLE_LEN_r44] = _GUARD_CALLABLE_LEN, + [_GUARD_CALLABLE_LEN_r55] = _GUARD_CALLABLE_LEN, [_CALL_LEN_r33] = _CALL_LEN, - [_GUARD_CALLABLE_ISINSTANCE_r03] = _GUARD_CALLABLE_ISINSTANCE, - [_GUARD_CALLABLE_ISINSTANCE_r13] = _GUARD_CALLABLE_ISINSTANCE, - [_GUARD_CALLABLE_ISINSTANCE_r23] = _GUARD_CALLABLE_ISINSTANCE, - [_GUARD_CALLABLE_ISINSTANCE_r33] = _GUARD_CALLABLE_ISINSTANCE, - [_CALL_ISINSTANCE_r31] = _CALL_ISINSTANCE, + [_GUARD_CALLABLE_ISINSTANCE_r04] = _GUARD_CALLABLE_ISINSTANCE, + [_GUARD_CALLABLE_ISINSTANCE_r14] = _GUARD_CALLABLE_ISINSTANCE, + [_GUARD_CALLABLE_ISINSTANCE_r24] = _GUARD_CALLABLE_ISINSTANCE, + [_GUARD_CALLABLE_ISINSTANCE_r34] = _GUARD_CALLABLE_ISINSTANCE, + [_GUARD_CALLABLE_ISINSTANCE_r44] = _GUARD_CALLABLE_ISINSTANCE, + [_GUARD_CALLABLE_ISINSTANCE_r55] = _GUARD_CALLABLE_ISINSTANCE, + [_CALL_ISINSTANCE_r41] = _CALL_ISINSTANCE, [_GUARD_CALLABLE_LIST_APPEND_r03] = _GUARD_CALLABLE_LIST_APPEND, [_GUARD_CALLABLE_LIST_APPEND_r13] = _GUARD_CALLABLE_LIST_APPEND, [_GUARD_CALLABLE_LIST_APPEND_r23] = _GUARD_CALLABLE_LIST_APPEND, [_GUARD_CALLABLE_LIST_APPEND_r33] = _GUARD_CALLABLE_LIST_APPEND, + [_GUARD_CALLABLE_LIST_APPEND_r44] = _GUARD_CALLABLE_LIST_APPEND, + [_GUARD_CALLABLE_LIST_APPEND_r55] = _GUARD_CALLABLE_LIST_APPEND, [_CALL_LIST_APPEND_r03] = _CALL_LIST_APPEND, [_CALL_LIST_APPEND_r13] = _CALL_LIST_APPEND, [_CALL_LIST_APPEND_r23] = _CALL_LIST_APPEND, [_CALL_LIST_APPEND_r33] = _CALL_LIST_APPEND, - [_CALL_METHOD_DESCRIPTOR_O_r03] = _CALL_METHOD_DESCRIPTOR_O, + [_CALL_LIST_APPEND_r44] = _CALL_LIST_APPEND, + [_CALL_LIST_APPEND_r55] = _CALL_LIST_APPEND, + [_CALL_METHOD_DESCRIPTOR_O_r04] = _CALL_METHOD_DESCRIPTOR_O, [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01] = _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, [_CALL_METHOD_DESCRIPTOR_NOARGS_r01] = _CALL_METHOD_DESCRIPTOR_NOARGS, [_CALL_METHOD_DESCRIPTOR_FAST_r01] = _CALL_METHOD_DESCRIPTOR_FAST, @@ -4097,22 +4348,28 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_EXPAND_METHOD_KW_r11] = _EXPAND_METHOD_KW, [_CHECK_IS_NOT_PY_CALLABLE_KW_r11] = _CHECK_IS_NOT_PY_CALLABLE_KW, [_CALL_KW_NON_PY_r11] = _CALL_KW_NON_PY, - [_MAKE_CALLARGS_A_TUPLE_r33] = _MAKE_CALLARGS_A_TUPLE, - [_CHECK_IS_PY_CALLABLE_EX_r03] = _CHECK_IS_PY_CALLABLE_EX, - [_CHECK_IS_PY_CALLABLE_EX_r13] = _CHECK_IS_PY_CALLABLE_EX, - [_CHECK_IS_PY_CALLABLE_EX_r23] = _CHECK_IS_PY_CALLABLE_EX, - [_CHECK_IS_PY_CALLABLE_EX_r33] = _CHECK_IS_PY_CALLABLE_EX, - [_PY_FRAME_EX_r31] = _PY_FRAME_EX, - [_CHECK_IS_NOT_PY_CALLABLE_EX_r03] = _CHECK_IS_NOT_PY_CALLABLE_EX, - [_CHECK_IS_NOT_PY_CALLABLE_EX_r13] = _CHECK_IS_NOT_PY_CALLABLE_EX, - [_CHECK_IS_NOT_PY_CALLABLE_EX_r23] = _CHECK_IS_NOT_PY_CALLABLE_EX, - [_CHECK_IS_NOT_PY_CALLABLE_EX_r33] = _CHECK_IS_NOT_PY_CALLABLE_EX, - [_CALL_FUNCTION_EX_NON_PY_GENERAL_r31] = _CALL_FUNCTION_EX_NON_PY_GENERAL, + [_MAKE_CALLARGS_A_TUPLE_r44] = _MAKE_CALLARGS_A_TUPLE, + [_CHECK_IS_PY_CALLABLE_EX_r04] = _CHECK_IS_PY_CALLABLE_EX, + [_CHECK_IS_PY_CALLABLE_EX_r14] = _CHECK_IS_PY_CALLABLE_EX, + [_CHECK_IS_PY_CALLABLE_EX_r24] = _CHECK_IS_PY_CALLABLE_EX, + [_CHECK_IS_PY_CALLABLE_EX_r34] = _CHECK_IS_PY_CALLABLE_EX, + [_CHECK_IS_PY_CALLABLE_EX_r44] = _CHECK_IS_PY_CALLABLE_EX, + [_CHECK_IS_PY_CALLABLE_EX_r55] = _CHECK_IS_PY_CALLABLE_EX, + [_PY_FRAME_EX_r41] = _PY_FRAME_EX, + [_CHECK_IS_NOT_PY_CALLABLE_EX_r04] = _CHECK_IS_NOT_PY_CALLABLE_EX, + [_CHECK_IS_NOT_PY_CALLABLE_EX_r14] = _CHECK_IS_NOT_PY_CALLABLE_EX, + [_CHECK_IS_NOT_PY_CALLABLE_EX_r24] = _CHECK_IS_NOT_PY_CALLABLE_EX, + [_CHECK_IS_NOT_PY_CALLABLE_EX_r34] = _CHECK_IS_NOT_PY_CALLABLE_EX, + [_CHECK_IS_NOT_PY_CALLABLE_EX_r44] = _CHECK_IS_NOT_PY_CALLABLE_EX, + [_CHECK_IS_NOT_PY_CALLABLE_EX_r55] = _CHECK_IS_NOT_PY_CALLABLE_EX, + [_CALL_FUNCTION_EX_NON_PY_GENERAL_r41] = _CALL_FUNCTION_EX_NON_PY_GENERAL, [_MAKE_FUNCTION_r11] = _MAKE_FUNCTION, [_SET_FUNCTION_ATTRIBUTE_r01] = _SET_FUNCTION_ATTRIBUTE, [_SET_FUNCTION_ATTRIBUTE_r11] = _SET_FUNCTION_ATTRIBUTE, [_SET_FUNCTION_ATTRIBUTE_r21] = _SET_FUNCTION_ATTRIBUTE, [_SET_FUNCTION_ATTRIBUTE_r32] = _SET_FUNCTION_ATTRIBUTE, + [_SET_FUNCTION_ATTRIBUTE_r43] = _SET_FUNCTION_ATTRIBUTE, + [_SET_FUNCTION_ATTRIBUTE_r54] = _SET_FUNCTION_ATTRIBUTE, [_RETURN_GENERATOR_r01] = _RETURN_GENERATOR, [_BUILD_SLICE_r01] = _BUILD_SLICE, [_CONVERT_VALUE_r11] = _CONVERT_VALUE, @@ -4121,112 +4378,163 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_COPY_1_r02] = _COPY_1, [_COPY_1_r12] = _COPY_1, [_COPY_1_r23] = _COPY_1, + [_COPY_1_r34] = _COPY_1, + [_COPY_1_r45] = _COPY_1, [_COPY_2_r03] = _COPY_2, [_COPY_2_r13] = _COPY_2, [_COPY_2_r23] = _COPY_2, - [_COPY_3_r03] = _COPY_3, - [_COPY_3_r13] = _COPY_3, - [_COPY_3_r23] = _COPY_3, - [_COPY_3_r33] = _COPY_3, + [_COPY_2_r34] = _COPY_2, + [_COPY_2_r45] = _COPY_2, + [_COPY_3_r04] = _COPY_3, + [_COPY_3_r14] = _COPY_3, + [_COPY_3_r24] = _COPY_3, + [_COPY_3_r34] = _COPY_3, + [_COPY_3_r45] = _COPY_3, [_COPY_r01] = _COPY, [_BINARY_OP_r23] = _BINARY_OP, [_SWAP_2_r02] = _SWAP_2, [_SWAP_2_r12] = _SWAP_2, [_SWAP_2_r22] = _SWAP_2, [_SWAP_2_r33] = _SWAP_2, + [_SWAP_2_r44] = _SWAP_2, + [_SWAP_2_r55] = _SWAP_2, [_SWAP_3_r03] = _SWAP_3, [_SWAP_3_r13] = _SWAP_3, [_SWAP_3_r23] = _SWAP_3, [_SWAP_3_r33] = _SWAP_3, + [_SWAP_3_r44] = _SWAP_3, + [_SWAP_3_r55] = _SWAP_3, [_SWAP_r11] = _SWAP, [_GUARD_IS_TRUE_POP_r00] = _GUARD_IS_TRUE_POP, [_GUARD_IS_TRUE_POP_r10] = _GUARD_IS_TRUE_POP, [_GUARD_IS_TRUE_POP_r21] = _GUARD_IS_TRUE_POP, [_GUARD_IS_TRUE_POP_r32] = _GUARD_IS_TRUE_POP, + [_GUARD_IS_TRUE_POP_r43] = _GUARD_IS_TRUE_POP, + [_GUARD_IS_TRUE_POP_r54] = _GUARD_IS_TRUE_POP, [_GUARD_IS_FALSE_POP_r00] = _GUARD_IS_FALSE_POP, [_GUARD_IS_FALSE_POP_r10] = _GUARD_IS_FALSE_POP, [_GUARD_IS_FALSE_POP_r21] = _GUARD_IS_FALSE_POP, [_GUARD_IS_FALSE_POP_r32] = _GUARD_IS_FALSE_POP, + [_GUARD_IS_FALSE_POP_r43] = _GUARD_IS_FALSE_POP, + [_GUARD_IS_FALSE_POP_r54] = _GUARD_IS_FALSE_POP, [_GUARD_BIT_IS_SET_POP_4_r00] = _GUARD_BIT_IS_SET_POP_4, [_GUARD_BIT_IS_SET_POP_4_r10] = _GUARD_BIT_IS_SET_POP_4, [_GUARD_BIT_IS_SET_POP_4_r21] = _GUARD_BIT_IS_SET_POP_4, [_GUARD_BIT_IS_SET_POP_4_r32] = _GUARD_BIT_IS_SET_POP_4, + [_GUARD_BIT_IS_SET_POP_4_r43] = _GUARD_BIT_IS_SET_POP_4, + [_GUARD_BIT_IS_SET_POP_4_r54] = _GUARD_BIT_IS_SET_POP_4, [_GUARD_BIT_IS_SET_POP_5_r00] = _GUARD_BIT_IS_SET_POP_5, [_GUARD_BIT_IS_SET_POP_5_r10] = _GUARD_BIT_IS_SET_POP_5, [_GUARD_BIT_IS_SET_POP_5_r21] = _GUARD_BIT_IS_SET_POP_5, [_GUARD_BIT_IS_SET_POP_5_r32] = _GUARD_BIT_IS_SET_POP_5, + [_GUARD_BIT_IS_SET_POP_5_r43] = _GUARD_BIT_IS_SET_POP_5, + [_GUARD_BIT_IS_SET_POP_5_r54] = _GUARD_BIT_IS_SET_POP_5, [_GUARD_BIT_IS_SET_POP_6_r00] = _GUARD_BIT_IS_SET_POP_6, [_GUARD_BIT_IS_SET_POP_6_r10] = _GUARD_BIT_IS_SET_POP_6, [_GUARD_BIT_IS_SET_POP_6_r21] = _GUARD_BIT_IS_SET_POP_6, [_GUARD_BIT_IS_SET_POP_6_r32] = _GUARD_BIT_IS_SET_POP_6, + [_GUARD_BIT_IS_SET_POP_6_r43] = _GUARD_BIT_IS_SET_POP_6, + [_GUARD_BIT_IS_SET_POP_6_r54] = _GUARD_BIT_IS_SET_POP_6, [_GUARD_BIT_IS_SET_POP_7_r00] = _GUARD_BIT_IS_SET_POP_7, [_GUARD_BIT_IS_SET_POP_7_r10] = _GUARD_BIT_IS_SET_POP_7, [_GUARD_BIT_IS_SET_POP_7_r21] = _GUARD_BIT_IS_SET_POP_7, [_GUARD_BIT_IS_SET_POP_7_r32] = _GUARD_BIT_IS_SET_POP_7, + [_GUARD_BIT_IS_SET_POP_7_r43] = _GUARD_BIT_IS_SET_POP_7, + [_GUARD_BIT_IS_SET_POP_7_r54] = _GUARD_BIT_IS_SET_POP_7, [_GUARD_BIT_IS_SET_POP_r00] = _GUARD_BIT_IS_SET_POP, [_GUARD_BIT_IS_SET_POP_r10] = _GUARD_BIT_IS_SET_POP, [_GUARD_BIT_IS_SET_POP_r21] = _GUARD_BIT_IS_SET_POP, [_GUARD_BIT_IS_SET_POP_r32] = _GUARD_BIT_IS_SET_POP, + [_GUARD_BIT_IS_SET_POP_r43] = _GUARD_BIT_IS_SET_POP, + [_GUARD_BIT_IS_SET_POP_r54] = _GUARD_BIT_IS_SET_POP, [_GUARD_BIT_IS_UNSET_POP_4_r00] = _GUARD_BIT_IS_UNSET_POP_4, [_GUARD_BIT_IS_UNSET_POP_4_r10] = _GUARD_BIT_IS_UNSET_POP_4, [_GUARD_BIT_IS_UNSET_POP_4_r21] = _GUARD_BIT_IS_UNSET_POP_4, [_GUARD_BIT_IS_UNSET_POP_4_r32] = _GUARD_BIT_IS_UNSET_POP_4, + [_GUARD_BIT_IS_UNSET_POP_4_r43] = _GUARD_BIT_IS_UNSET_POP_4, + [_GUARD_BIT_IS_UNSET_POP_4_r54] = _GUARD_BIT_IS_UNSET_POP_4, [_GUARD_BIT_IS_UNSET_POP_5_r00] = _GUARD_BIT_IS_UNSET_POP_5, [_GUARD_BIT_IS_UNSET_POP_5_r10] = _GUARD_BIT_IS_UNSET_POP_5, [_GUARD_BIT_IS_UNSET_POP_5_r21] = _GUARD_BIT_IS_UNSET_POP_5, [_GUARD_BIT_IS_UNSET_POP_5_r32] = _GUARD_BIT_IS_UNSET_POP_5, + [_GUARD_BIT_IS_UNSET_POP_5_r43] = _GUARD_BIT_IS_UNSET_POP_5, + [_GUARD_BIT_IS_UNSET_POP_5_r54] = _GUARD_BIT_IS_UNSET_POP_5, [_GUARD_BIT_IS_UNSET_POP_6_r00] = _GUARD_BIT_IS_UNSET_POP_6, [_GUARD_BIT_IS_UNSET_POP_6_r10] = _GUARD_BIT_IS_UNSET_POP_6, [_GUARD_BIT_IS_UNSET_POP_6_r21] = _GUARD_BIT_IS_UNSET_POP_6, [_GUARD_BIT_IS_UNSET_POP_6_r32] = _GUARD_BIT_IS_UNSET_POP_6, + [_GUARD_BIT_IS_UNSET_POP_6_r43] = _GUARD_BIT_IS_UNSET_POP_6, + [_GUARD_BIT_IS_UNSET_POP_6_r54] = _GUARD_BIT_IS_UNSET_POP_6, [_GUARD_BIT_IS_UNSET_POP_7_r00] = _GUARD_BIT_IS_UNSET_POP_7, [_GUARD_BIT_IS_UNSET_POP_7_r10] = _GUARD_BIT_IS_UNSET_POP_7, [_GUARD_BIT_IS_UNSET_POP_7_r21] = _GUARD_BIT_IS_UNSET_POP_7, [_GUARD_BIT_IS_UNSET_POP_7_r32] = _GUARD_BIT_IS_UNSET_POP_7, + [_GUARD_BIT_IS_UNSET_POP_7_r43] = _GUARD_BIT_IS_UNSET_POP_7, + [_GUARD_BIT_IS_UNSET_POP_7_r54] = _GUARD_BIT_IS_UNSET_POP_7, [_GUARD_BIT_IS_UNSET_POP_r00] = _GUARD_BIT_IS_UNSET_POP, [_GUARD_BIT_IS_UNSET_POP_r10] = _GUARD_BIT_IS_UNSET_POP, [_GUARD_BIT_IS_UNSET_POP_r21] = _GUARD_BIT_IS_UNSET_POP, [_GUARD_BIT_IS_UNSET_POP_r32] = _GUARD_BIT_IS_UNSET_POP, + [_GUARD_BIT_IS_UNSET_POP_r43] = _GUARD_BIT_IS_UNSET_POP, + [_GUARD_BIT_IS_UNSET_POP_r54] = _GUARD_BIT_IS_UNSET_POP, [_GUARD_IS_NONE_POP_r00] = _GUARD_IS_NONE_POP, [_GUARD_IS_NONE_POP_r10] = _GUARD_IS_NONE_POP, [_GUARD_IS_NONE_POP_r21] = _GUARD_IS_NONE_POP, [_GUARD_IS_NONE_POP_r32] = _GUARD_IS_NONE_POP, + [_GUARD_IS_NONE_POP_r43] = _GUARD_IS_NONE_POP, + [_GUARD_IS_NONE_POP_r54] = _GUARD_IS_NONE_POP, [_GUARD_IS_NOT_NONE_POP_r10] = _GUARD_IS_NOT_NONE_POP, [_JUMP_TO_TOP_r00] = _JUMP_TO_TOP, [_SET_IP_r00] = _SET_IP, [_SET_IP_r11] = _SET_IP, [_SET_IP_r22] = _SET_IP, [_SET_IP_r33] = _SET_IP, + [_SET_IP_r44] = _SET_IP, + [_SET_IP_r55] = _SET_IP, [_CHECK_STACK_SPACE_OPERAND_r00] = _CHECK_STACK_SPACE_OPERAND, [_CHECK_STACK_SPACE_OPERAND_r11] = _CHECK_STACK_SPACE_OPERAND, [_CHECK_STACK_SPACE_OPERAND_r22] = _CHECK_STACK_SPACE_OPERAND, [_CHECK_STACK_SPACE_OPERAND_r33] = _CHECK_STACK_SPACE_OPERAND, + [_CHECK_STACK_SPACE_OPERAND_r44] = _CHECK_STACK_SPACE_OPERAND, + [_CHECK_STACK_SPACE_OPERAND_r55] = _CHECK_STACK_SPACE_OPERAND, [_SAVE_RETURN_OFFSET_r00] = _SAVE_RETURN_OFFSET, [_SAVE_RETURN_OFFSET_r11] = _SAVE_RETURN_OFFSET, [_SAVE_RETURN_OFFSET_r22] = _SAVE_RETURN_OFFSET, [_SAVE_RETURN_OFFSET_r33] = _SAVE_RETURN_OFFSET, + [_SAVE_RETURN_OFFSET_r44] = _SAVE_RETURN_OFFSET, + [_SAVE_RETURN_OFFSET_r55] = _SAVE_RETURN_OFFSET, [_EXIT_TRACE_r00] = _EXIT_TRACE, [_EXIT_TRACE_r10] = _EXIT_TRACE, [_EXIT_TRACE_r20] = _EXIT_TRACE, [_EXIT_TRACE_r30] = _EXIT_TRACE, + [_EXIT_TRACE_r40] = _EXIT_TRACE, + [_EXIT_TRACE_r50] = _EXIT_TRACE, [_DYNAMIC_EXIT_r00] = _DYNAMIC_EXIT, [_DYNAMIC_EXIT_r10] = _DYNAMIC_EXIT, [_DYNAMIC_EXIT_r20] = _DYNAMIC_EXIT, [_DYNAMIC_EXIT_r30] = _DYNAMIC_EXIT, + [_DYNAMIC_EXIT_r40] = _DYNAMIC_EXIT, + [_DYNAMIC_EXIT_r50] = _DYNAMIC_EXIT, [_CHECK_VALIDITY_r00] = _CHECK_VALIDITY, [_CHECK_VALIDITY_r11] = _CHECK_VALIDITY, [_CHECK_VALIDITY_r22] = _CHECK_VALIDITY, [_CHECK_VALIDITY_r33] = _CHECK_VALIDITY, + [_CHECK_VALIDITY_r44] = _CHECK_VALIDITY, + [_CHECK_VALIDITY_r55] = _CHECK_VALIDITY, [_LOAD_CONST_INLINE_r01] = _LOAD_CONST_INLINE, [_LOAD_CONST_INLINE_r12] = _LOAD_CONST_INLINE, [_LOAD_CONST_INLINE_r23] = _LOAD_CONST_INLINE, + [_LOAD_CONST_INLINE_r34] = _LOAD_CONST_INLINE, + [_LOAD_CONST_INLINE_r45] = _LOAD_CONST_INLINE, [_POP_TOP_LOAD_CONST_INLINE_r11] = _POP_TOP_LOAD_CONST_INLINE, [_LOAD_CONST_INLINE_BORROW_r01] = _LOAD_CONST_INLINE_BORROW, [_LOAD_CONST_INLINE_BORROW_r12] = _LOAD_CONST_INLINE_BORROW, [_LOAD_CONST_INLINE_BORROW_r23] = _LOAD_CONST_INLINE_BORROW, + [_LOAD_CONST_INLINE_BORROW_r34] = _LOAD_CONST_INLINE_BORROW, + [_LOAD_CONST_INLINE_BORROW_r45] = _LOAD_CONST_INLINE_BORROW, [_POP_CALL_r20] = _POP_CALL, [_POP_CALL_ONE_r30] = _POP_CALL_ONE, - [_POP_CALL_TWO_r30] = _POP_CALL_TWO, + [_POP_CALL_TWO_r40] = _POP_CALL_TWO, [_POP_TOP_LOAD_CONST_INLINE_BORROW_r11] = _POP_TOP_LOAD_CONST_INLINE_BORROW, [_POP_TWO_LOAD_CONST_INLINE_BORROW_r21] = _POP_TWO_LOAD_CONST_INLINE_BORROW, [_POP_CALL_LOAD_CONST_INLINE_BORROW_r21] = _POP_CALL_LOAD_CONST_INLINE_BORROW, @@ -4234,83 +4542,135 @@ const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = { [_INSERT_1_LOAD_CONST_INLINE_r02] = _INSERT_1_LOAD_CONST_INLINE, [_INSERT_1_LOAD_CONST_INLINE_r12] = _INSERT_1_LOAD_CONST_INLINE, [_INSERT_1_LOAD_CONST_INLINE_r23] = _INSERT_1_LOAD_CONST_INLINE, + [_INSERT_1_LOAD_CONST_INLINE_r34] = _INSERT_1_LOAD_CONST_INLINE, + [_INSERT_1_LOAD_CONST_INLINE_r45] = _INSERT_1_LOAD_CONST_INLINE, [_INSERT_1_LOAD_CONST_INLINE_BORROW_r02] = _INSERT_1_LOAD_CONST_INLINE_BORROW, [_INSERT_1_LOAD_CONST_INLINE_BORROW_r12] = _INSERT_1_LOAD_CONST_INLINE_BORROW, [_INSERT_1_LOAD_CONST_INLINE_BORROW_r23] = _INSERT_1_LOAD_CONST_INLINE_BORROW, + [_INSERT_1_LOAD_CONST_INLINE_BORROW_r34] = _INSERT_1_LOAD_CONST_INLINE_BORROW, + [_INSERT_1_LOAD_CONST_INLINE_BORROW_r45] = _INSERT_1_LOAD_CONST_INLINE_BORROW, [_INSERT_2_LOAD_CONST_INLINE_BORROW_r03] = _INSERT_2_LOAD_CONST_INLINE_BORROW, [_INSERT_2_LOAD_CONST_INLINE_BORROW_r13] = _INSERT_2_LOAD_CONST_INLINE_BORROW, [_INSERT_2_LOAD_CONST_INLINE_BORROW_r23] = _INSERT_2_LOAD_CONST_INLINE_BORROW, + [_INSERT_2_LOAD_CONST_INLINE_BORROW_r34] = _INSERT_2_LOAD_CONST_INLINE_BORROW, + [_INSERT_2_LOAD_CONST_INLINE_BORROW_r45] = _INSERT_2_LOAD_CONST_INLINE_BORROW, [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r02] = _SHUFFLE_2_LOAD_CONST_INLINE_BORROW, [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12] = _SHUFFLE_2_LOAD_CONST_INLINE_BORROW, [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22] = _SHUFFLE_2_LOAD_CONST_INLINE_BORROW, [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32] = _SHUFFLE_2_LOAD_CONST_INLINE_BORROW, + [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r43] = _SHUFFLE_2_LOAD_CONST_INLINE_BORROW, + [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r54] = _SHUFFLE_2_LOAD_CONST_INLINE_BORROW, [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, - [_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31] = _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW, + [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r44] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, + [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r55] = _SHUFFLE_3_LOAD_CONST_INLINE_BORROW, + [_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r41] = _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW, [_LOAD_CONST_UNDER_INLINE_r02] = _LOAD_CONST_UNDER_INLINE, [_LOAD_CONST_UNDER_INLINE_r12] = _LOAD_CONST_UNDER_INLINE, [_LOAD_CONST_UNDER_INLINE_r23] = _LOAD_CONST_UNDER_INLINE, + [_LOAD_CONST_UNDER_INLINE_r34] = _LOAD_CONST_UNDER_INLINE, + [_LOAD_CONST_UNDER_INLINE_r45] = _LOAD_CONST_UNDER_INLINE, [_LOAD_CONST_UNDER_INLINE_BORROW_r02] = _LOAD_CONST_UNDER_INLINE_BORROW, [_LOAD_CONST_UNDER_INLINE_BORROW_r12] = _LOAD_CONST_UNDER_INLINE_BORROW, [_LOAD_CONST_UNDER_INLINE_BORROW_r23] = _LOAD_CONST_UNDER_INLINE_BORROW, + [_LOAD_CONST_UNDER_INLINE_BORROW_r34] = _LOAD_CONST_UNDER_INLINE_BORROW, + [_LOAD_CONST_UNDER_INLINE_BORROW_r45] = _LOAD_CONST_UNDER_INLINE_BORROW, [_START_EXECUTOR_r00] = _START_EXECUTOR, [_MAKE_WARM_r00] = _MAKE_WARM, [_MAKE_WARM_r11] = _MAKE_WARM, [_MAKE_WARM_r22] = _MAKE_WARM, [_MAKE_WARM_r33] = _MAKE_WARM, + [_MAKE_WARM_r44] = _MAKE_WARM, + [_MAKE_WARM_r55] = _MAKE_WARM, [_FATAL_ERROR_r00] = _FATAL_ERROR, [_FATAL_ERROR_r11] = _FATAL_ERROR, [_FATAL_ERROR_r22] = _FATAL_ERROR, [_FATAL_ERROR_r33] = _FATAL_ERROR, + [_FATAL_ERROR_r44] = _FATAL_ERROR, + [_FATAL_ERROR_r55] = _FATAL_ERROR, [_DEOPT_r00] = _DEOPT, [_DEOPT_r10] = _DEOPT, [_DEOPT_r20] = _DEOPT, [_DEOPT_r30] = _DEOPT, + [_DEOPT_r40] = _DEOPT, + [_DEOPT_r50] = _DEOPT, [_HANDLE_PENDING_AND_DEOPT_r00] = _HANDLE_PENDING_AND_DEOPT, [_HANDLE_PENDING_AND_DEOPT_r10] = _HANDLE_PENDING_AND_DEOPT, [_HANDLE_PENDING_AND_DEOPT_r20] = _HANDLE_PENDING_AND_DEOPT, [_HANDLE_PENDING_AND_DEOPT_r30] = _HANDLE_PENDING_AND_DEOPT, + [_HANDLE_PENDING_AND_DEOPT_r40] = _HANDLE_PENDING_AND_DEOPT, + [_HANDLE_PENDING_AND_DEOPT_r50] = _HANDLE_PENDING_AND_DEOPT, [_ERROR_POP_N_r00] = _ERROR_POP_N, [_SPILL_OR_RELOAD_r01] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r02] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r03] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r04] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r05] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r10] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r12] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r13] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r14] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r15] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r20] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r21] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r23] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r24] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r25] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r30] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r31] = _SPILL_OR_RELOAD, [_SPILL_OR_RELOAD_r32] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r34] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r35] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r40] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r41] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r42] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r43] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r45] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r50] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r51] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r52] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r53] = _SPILL_OR_RELOAD, + [_SPILL_OR_RELOAD_r54] = _SPILL_OR_RELOAD, [_TIER2_RESUME_CHECK_r00] = _TIER2_RESUME_CHECK, [_TIER2_RESUME_CHECK_r11] = _TIER2_RESUME_CHECK, [_TIER2_RESUME_CHECK_r22] = _TIER2_RESUME_CHECK, [_TIER2_RESUME_CHECK_r33] = _TIER2_RESUME_CHECK, + [_TIER2_RESUME_CHECK_r44] = _TIER2_RESUME_CHECK, + [_TIER2_RESUME_CHECK_r55] = _TIER2_RESUME_CHECK, [_COLD_EXIT_r00] = _COLD_EXIT, [_COLD_DYNAMIC_EXIT_r00] = _COLD_DYNAMIC_EXIT, [_GUARD_CODE_VERSION_r00] = _GUARD_CODE_VERSION, [_GUARD_CODE_VERSION_r11] = _GUARD_CODE_VERSION, [_GUARD_CODE_VERSION_r22] = _GUARD_CODE_VERSION, [_GUARD_CODE_VERSION_r33] = _GUARD_CODE_VERSION, + [_GUARD_CODE_VERSION_r44] = _GUARD_CODE_VERSION, + [_GUARD_CODE_VERSION_r55] = _GUARD_CODE_VERSION, [_GUARD_IP__PUSH_FRAME_r00] = _GUARD_IP__PUSH_FRAME, [_GUARD_IP__PUSH_FRAME_r11] = _GUARD_IP__PUSH_FRAME, [_GUARD_IP__PUSH_FRAME_r22] = _GUARD_IP__PUSH_FRAME, [_GUARD_IP__PUSH_FRAME_r33] = _GUARD_IP__PUSH_FRAME, + [_GUARD_IP__PUSH_FRAME_r44] = _GUARD_IP__PUSH_FRAME, + [_GUARD_IP__PUSH_FRAME_r55] = _GUARD_IP__PUSH_FRAME, [_GUARD_IP_YIELD_VALUE_r00] = _GUARD_IP_YIELD_VALUE, [_GUARD_IP_YIELD_VALUE_r11] = _GUARD_IP_YIELD_VALUE, [_GUARD_IP_YIELD_VALUE_r22] = _GUARD_IP_YIELD_VALUE, [_GUARD_IP_YIELD_VALUE_r33] = _GUARD_IP_YIELD_VALUE, + [_GUARD_IP_YIELD_VALUE_r44] = _GUARD_IP_YIELD_VALUE, + [_GUARD_IP_YIELD_VALUE_r55] = _GUARD_IP_YIELD_VALUE, [_GUARD_IP_RETURN_VALUE_r00] = _GUARD_IP_RETURN_VALUE, [_GUARD_IP_RETURN_VALUE_r11] = _GUARD_IP_RETURN_VALUE, [_GUARD_IP_RETURN_VALUE_r22] = _GUARD_IP_RETURN_VALUE, [_GUARD_IP_RETURN_VALUE_r33] = _GUARD_IP_RETURN_VALUE, + [_GUARD_IP_RETURN_VALUE_r44] = _GUARD_IP_RETURN_VALUE, + [_GUARD_IP_RETURN_VALUE_r55] = _GUARD_IP_RETURN_VALUE, [_GUARD_IP_RETURN_GENERATOR_r00] = _GUARD_IP_RETURN_GENERATOR, [_GUARD_IP_RETURN_GENERATOR_r11] = _GUARD_IP_RETURN_GENERATOR, [_GUARD_IP_RETURN_GENERATOR_r22] = _GUARD_IP_RETURN_GENERATOR, [_GUARD_IP_RETURN_GENERATOR_r33] = _GUARD_IP_RETURN_GENERATOR, + [_GUARD_IP_RETURN_GENERATOR_r44] = _GUARD_IP_RETURN_GENERATOR, + [_GUARD_IP_RETURN_GENERATOR_r55] = _GUARD_IP_RETURN_GENERATOR, }; const uint16_t _PyUop_SpillsAndReloads[4][4] = { @@ -4335,14 +4695,20 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_BINARY_OP_ADD_FLOAT_r03] = "_BINARY_OP_ADD_FLOAT_r03", [_BINARY_OP_ADD_FLOAT_r13] = "_BINARY_OP_ADD_FLOAT_r13", [_BINARY_OP_ADD_FLOAT_r23] = "_BINARY_OP_ADD_FLOAT_r23", + [_BINARY_OP_ADD_FLOAT_r34] = "_BINARY_OP_ADD_FLOAT_r34", + [_BINARY_OP_ADD_FLOAT_r45] = "_BINARY_OP_ADD_FLOAT_r45", [_BINARY_OP_ADD_INT] = "_BINARY_OP_ADD_INT", [_BINARY_OP_ADD_INT_r03] = "_BINARY_OP_ADD_INT_r03", [_BINARY_OP_ADD_INT_r13] = "_BINARY_OP_ADD_INT_r13", [_BINARY_OP_ADD_INT_r23] = "_BINARY_OP_ADD_INT_r23", + [_BINARY_OP_ADD_INT_r34] = "_BINARY_OP_ADD_INT_r34", + [_BINARY_OP_ADD_INT_r45] = "_BINARY_OP_ADD_INT_r45", [_BINARY_OP_ADD_UNICODE] = "_BINARY_OP_ADD_UNICODE", [_BINARY_OP_ADD_UNICODE_r03] = "_BINARY_OP_ADD_UNICODE_r03", [_BINARY_OP_ADD_UNICODE_r13] = "_BINARY_OP_ADD_UNICODE_r13", [_BINARY_OP_ADD_UNICODE_r23] = "_BINARY_OP_ADD_UNICODE_r23", + [_BINARY_OP_ADD_UNICODE_r34] = "_BINARY_OP_ADD_UNICODE_r34", + [_BINARY_OP_ADD_UNICODE_r45] = "_BINARY_OP_ADD_UNICODE_r45", [_BINARY_OP_EXTEND] = "_BINARY_OP_EXTEND", [_BINARY_OP_EXTEND_r23] = "_BINARY_OP_EXTEND_r23", [_BINARY_OP_INPLACE_ADD_UNICODE] = "_BINARY_OP_INPLACE_ADD_UNICODE", @@ -4351,10 +4717,14 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_BINARY_OP_MULTIPLY_FLOAT_r03] = "_BINARY_OP_MULTIPLY_FLOAT_r03", [_BINARY_OP_MULTIPLY_FLOAT_r13] = "_BINARY_OP_MULTIPLY_FLOAT_r13", [_BINARY_OP_MULTIPLY_FLOAT_r23] = "_BINARY_OP_MULTIPLY_FLOAT_r23", + [_BINARY_OP_MULTIPLY_FLOAT_r34] = "_BINARY_OP_MULTIPLY_FLOAT_r34", + [_BINARY_OP_MULTIPLY_FLOAT_r45] = "_BINARY_OP_MULTIPLY_FLOAT_r45", [_BINARY_OP_MULTIPLY_INT] = "_BINARY_OP_MULTIPLY_INT", [_BINARY_OP_MULTIPLY_INT_r03] = "_BINARY_OP_MULTIPLY_INT_r03", [_BINARY_OP_MULTIPLY_INT_r13] = "_BINARY_OP_MULTIPLY_INT_r13", [_BINARY_OP_MULTIPLY_INT_r23] = "_BINARY_OP_MULTIPLY_INT_r23", + [_BINARY_OP_MULTIPLY_INT_r34] = "_BINARY_OP_MULTIPLY_INT_r34", + [_BINARY_OP_MULTIPLY_INT_r45] = "_BINARY_OP_MULTIPLY_INT_r45", [_BINARY_OP_SUBSCR_CHECK_FUNC] = "_BINARY_OP_SUBSCR_CHECK_FUNC", [_BINARY_OP_SUBSCR_CHECK_FUNC_r23] = "_BINARY_OP_SUBSCR_CHECK_FUNC_r23", [_BINARY_OP_SUBSCR_DICT] = "_BINARY_OP_SUBSCR_DICT", @@ -4364,6 +4734,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_BINARY_OP_SUBSCR_INIT_CALL_r11] = "_BINARY_OP_SUBSCR_INIT_CALL_r11", [_BINARY_OP_SUBSCR_INIT_CALL_r21] = "_BINARY_OP_SUBSCR_INIT_CALL_r21", [_BINARY_OP_SUBSCR_INIT_CALL_r31] = "_BINARY_OP_SUBSCR_INIT_CALL_r31", + [_BINARY_OP_SUBSCR_INIT_CALL_r42] = "_BINARY_OP_SUBSCR_INIT_CALL_r42", + [_BINARY_OP_SUBSCR_INIT_CALL_r53] = "_BINARY_OP_SUBSCR_INIT_CALL_r53", [_BINARY_OP_SUBSCR_LIST_INT] = "_BINARY_OP_SUBSCR_LIST_INT", [_BINARY_OP_SUBSCR_LIST_INT_r23] = "_BINARY_OP_SUBSCR_LIST_INT_r23", [_BINARY_OP_SUBSCR_LIST_SLICE] = "_BINARY_OP_SUBSCR_LIST_SLICE", @@ -4374,16 +4746,22 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_BINARY_OP_SUBSCR_TUPLE_INT_r03] = "_BINARY_OP_SUBSCR_TUPLE_INT_r03", [_BINARY_OP_SUBSCR_TUPLE_INT_r13] = "_BINARY_OP_SUBSCR_TUPLE_INT_r13", [_BINARY_OP_SUBSCR_TUPLE_INT_r23] = "_BINARY_OP_SUBSCR_TUPLE_INT_r23", + [_BINARY_OP_SUBSCR_TUPLE_INT_r34] = "_BINARY_OP_SUBSCR_TUPLE_INT_r34", + [_BINARY_OP_SUBSCR_TUPLE_INT_r45] = "_BINARY_OP_SUBSCR_TUPLE_INT_r45", [_BINARY_OP_SUBSCR_USTR_INT] = "_BINARY_OP_SUBSCR_USTR_INT", [_BINARY_OP_SUBSCR_USTR_INT_r23] = "_BINARY_OP_SUBSCR_USTR_INT_r23", [_BINARY_OP_SUBTRACT_FLOAT] = "_BINARY_OP_SUBTRACT_FLOAT", [_BINARY_OP_SUBTRACT_FLOAT_r03] = "_BINARY_OP_SUBTRACT_FLOAT_r03", [_BINARY_OP_SUBTRACT_FLOAT_r13] = "_BINARY_OP_SUBTRACT_FLOAT_r13", [_BINARY_OP_SUBTRACT_FLOAT_r23] = "_BINARY_OP_SUBTRACT_FLOAT_r23", + [_BINARY_OP_SUBTRACT_FLOAT_r34] = "_BINARY_OP_SUBTRACT_FLOAT_r34", + [_BINARY_OP_SUBTRACT_FLOAT_r45] = "_BINARY_OP_SUBTRACT_FLOAT_r45", [_BINARY_OP_SUBTRACT_INT] = "_BINARY_OP_SUBTRACT_INT", [_BINARY_OP_SUBTRACT_INT_r03] = "_BINARY_OP_SUBTRACT_INT_r03", [_BINARY_OP_SUBTRACT_INT_r13] = "_BINARY_OP_SUBTRACT_INT_r13", [_BINARY_OP_SUBTRACT_INT_r23] = "_BINARY_OP_SUBTRACT_INT_r23", + [_BINARY_OP_SUBTRACT_INT_r34] = "_BINARY_OP_SUBTRACT_INT_r34", + [_BINARY_OP_SUBTRACT_INT_r45] = "_BINARY_OP_SUBTRACT_INT_r45", [_BINARY_SLICE] = "_BINARY_SLICE", [_BINARY_SLICE_r31] = "_BINARY_SLICE_r31", [_BUILD_INTERPOLATION] = "_BUILD_INTERPOLATION", @@ -4411,13 +4789,13 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CALL_BUILTIN_O] = "_CALL_BUILTIN_O", [_CALL_BUILTIN_O_r03] = "_CALL_BUILTIN_O_r03", [_CALL_FUNCTION_EX_NON_PY_GENERAL] = "_CALL_FUNCTION_EX_NON_PY_GENERAL", - [_CALL_FUNCTION_EX_NON_PY_GENERAL_r31] = "_CALL_FUNCTION_EX_NON_PY_GENERAL_r31", + [_CALL_FUNCTION_EX_NON_PY_GENERAL_r41] = "_CALL_FUNCTION_EX_NON_PY_GENERAL_r41", [_CALL_INTRINSIC_1] = "_CALL_INTRINSIC_1", [_CALL_INTRINSIC_1_r11] = "_CALL_INTRINSIC_1_r11", [_CALL_INTRINSIC_2] = "_CALL_INTRINSIC_2", [_CALL_INTRINSIC_2_r21] = "_CALL_INTRINSIC_2_r21", [_CALL_ISINSTANCE] = "_CALL_ISINSTANCE", - [_CALL_ISINSTANCE_r31] = "_CALL_ISINSTANCE_r31", + [_CALL_ISINSTANCE_r41] = "_CALL_ISINSTANCE_r41", [_CALL_KW_NON_PY] = "_CALL_KW_NON_PY", [_CALL_KW_NON_PY_r11] = "_CALL_KW_NON_PY_r11", [_CALL_LEN] = "_CALL_LEN", @@ -4427,6 +4805,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CALL_LIST_APPEND_r13] = "_CALL_LIST_APPEND_r13", [_CALL_LIST_APPEND_r23] = "_CALL_LIST_APPEND_r23", [_CALL_LIST_APPEND_r33] = "_CALL_LIST_APPEND_r33", + [_CALL_LIST_APPEND_r44] = "_CALL_LIST_APPEND_r44", + [_CALL_LIST_APPEND_r55] = "_CALL_LIST_APPEND_r55", [_CALL_METHOD_DESCRIPTOR_FAST] = "_CALL_METHOD_DESCRIPTOR_FAST", [_CALL_METHOD_DESCRIPTOR_FAST_r01] = "_CALL_METHOD_DESCRIPTOR_FAST_r01", [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = "_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", @@ -4434,7 +4814,7 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CALL_METHOD_DESCRIPTOR_NOARGS] = "_CALL_METHOD_DESCRIPTOR_NOARGS", [_CALL_METHOD_DESCRIPTOR_NOARGS_r01] = "_CALL_METHOD_DESCRIPTOR_NOARGS_r01", [_CALL_METHOD_DESCRIPTOR_O] = "_CALL_METHOD_DESCRIPTOR_O", - [_CALL_METHOD_DESCRIPTOR_O_r03] = "_CALL_METHOD_DESCRIPTOR_O_r03", + [_CALL_METHOD_DESCRIPTOR_O_r04] = "_CALL_METHOD_DESCRIPTOR_O_r04", [_CALL_NON_PY_GENERAL] = "_CALL_NON_PY_GENERAL", [_CALL_NON_PY_GENERAL_r01] = "_CALL_NON_PY_GENERAL_r01", [_CALL_STR_1] = "_CALL_STR_1", @@ -4446,6 +4826,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CALL_TYPE_1_r12] = "_CALL_TYPE_1_r12", [_CALL_TYPE_1_r22] = "_CALL_TYPE_1_r22", [_CALL_TYPE_1_r32] = "_CALL_TYPE_1_r32", + [_CALL_TYPE_1_r43] = "_CALL_TYPE_1_r43", + [_CALL_TYPE_1_r54] = "_CALL_TYPE_1_r54", [_CHECK_AND_ALLOCATE_OBJECT] = "_CHECK_AND_ALLOCATE_OBJECT", [_CHECK_AND_ALLOCATE_OBJECT_r00] = "_CHECK_AND_ALLOCATE_OBJECT_r00", [_CHECK_ATTR_CLASS] = "_CHECK_ATTR_CLASS", @@ -4453,11 +4835,15 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CHECK_ATTR_CLASS_r11] = "_CHECK_ATTR_CLASS_r11", [_CHECK_ATTR_CLASS_r22] = "_CHECK_ATTR_CLASS_r22", [_CHECK_ATTR_CLASS_r33] = "_CHECK_ATTR_CLASS_r33", + [_CHECK_ATTR_CLASS_r44] = "_CHECK_ATTR_CLASS_r44", + [_CHECK_ATTR_CLASS_r55] = "_CHECK_ATTR_CLASS_r55", [_CHECK_ATTR_METHOD_LAZY_DICT] = "_CHECK_ATTR_METHOD_LAZY_DICT", [_CHECK_ATTR_METHOD_LAZY_DICT_r01] = "_CHECK_ATTR_METHOD_LAZY_DICT_r01", [_CHECK_ATTR_METHOD_LAZY_DICT_r11] = "_CHECK_ATTR_METHOD_LAZY_DICT_r11", [_CHECK_ATTR_METHOD_LAZY_DICT_r22] = "_CHECK_ATTR_METHOD_LAZY_DICT_r22", [_CHECK_ATTR_METHOD_LAZY_DICT_r33] = "_CHECK_ATTR_METHOD_LAZY_DICT_r33", + [_CHECK_ATTR_METHOD_LAZY_DICT_r44] = "_CHECK_ATTR_METHOD_LAZY_DICT_r44", + [_CHECK_ATTR_METHOD_LAZY_DICT_r55] = "_CHECK_ATTR_METHOD_LAZY_DICT_r55", [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = "_CHECK_CALL_BOUND_METHOD_EXACT_ARGS", [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00] = "_CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00", [_CHECK_EG_MATCH] = "_CHECK_EG_MATCH", @@ -4473,27 +4859,35 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CHECK_FUNCTION_VERSION_INLINE_r11] = "_CHECK_FUNCTION_VERSION_INLINE_r11", [_CHECK_FUNCTION_VERSION_INLINE_r22] = "_CHECK_FUNCTION_VERSION_INLINE_r22", [_CHECK_FUNCTION_VERSION_INLINE_r33] = "_CHECK_FUNCTION_VERSION_INLINE_r33", + [_CHECK_FUNCTION_VERSION_INLINE_r44] = "_CHECK_FUNCTION_VERSION_INLINE_r44", + [_CHECK_FUNCTION_VERSION_INLINE_r55] = "_CHECK_FUNCTION_VERSION_INLINE_r55", [_CHECK_FUNCTION_VERSION_KW] = "_CHECK_FUNCTION_VERSION_KW", [_CHECK_FUNCTION_VERSION_KW_r11] = "_CHECK_FUNCTION_VERSION_KW_r11", [_CHECK_IS_NOT_PY_CALLABLE] = "_CHECK_IS_NOT_PY_CALLABLE", [_CHECK_IS_NOT_PY_CALLABLE_r00] = "_CHECK_IS_NOT_PY_CALLABLE_r00", [_CHECK_IS_NOT_PY_CALLABLE_EX] = "_CHECK_IS_NOT_PY_CALLABLE_EX", - [_CHECK_IS_NOT_PY_CALLABLE_EX_r03] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r03", - [_CHECK_IS_NOT_PY_CALLABLE_EX_r13] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r13", - [_CHECK_IS_NOT_PY_CALLABLE_EX_r23] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r23", - [_CHECK_IS_NOT_PY_CALLABLE_EX_r33] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r33", + [_CHECK_IS_NOT_PY_CALLABLE_EX_r04] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r04", + [_CHECK_IS_NOT_PY_CALLABLE_EX_r14] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r14", + [_CHECK_IS_NOT_PY_CALLABLE_EX_r24] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r24", + [_CHECK_IS_NOT_PY_CALLABLE_EX_r34] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r34", + [_CHECK_IS_NOT_PY_CALLABLE_EX_r44] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r44", + [_CHECK_IS_NOT_PY_CALLABLE_EX_r55] = "_CHECK_IS_NOT_PY_CALLABLE_EX_r55", [_CHECK_IS_NOT_PY_CALLABLE_KW] = "_CHECK_IS_NOT_PY_CALLABLE_KW", [_CHECK_IS_NOT_PY_CALLABLE_KW_r11] = "_CHECK_IS_NOT_PY_CALLABLE_KW_r11", [_CHECK_IS_PY_CALLABLE_EX] = "_CHECK_IS_PY_CALLABLE_EX", - [_CHECK_IS_PY_CALLABLE_EX_r03] = "_CHECK_IS_PY_CALLABLE_EX_r03", - [_CHECK_IS_PY_CALLABLE_EX_r13] = "_CHECK_IS_PY_CALLABLE_EX_r13", - [_CHECK_IS_PY_CALLABLE_EX_r23] = "_CHECK_IS_PY_CALLABLE_EX_r23", - [_CHECK_IS_PY_CALLABLE_EX_r33] = "_CHECK_IS_PY_CALLABLE_EX_r33", + [_CHECK_IS_PY_CALLABLE_EX_r04] = "_CHECK_IS_PY_CALLABLE_EX_r04", + [_CHECK_IS_PY_CALLABLE_EX_r14] = "_CHECK_IS_PY_CALLABLE_EX_r14", + [_CHECK_IS_PY_CALLABLE_EX_r24] = "_CHECK_IS_PY_CALLABLE_EX_r24", + [_CHECK_IS_PY_CALLABLE_EX_r34] = "_CHECK_IS_PY_CALLABLE_EX_r34", + [_CHECK_IS_PY_CALLABLE_EX_r44] = "_CHECK_IS_PY_CALLABLE_EX_r44", + [_CHECK_IS_PY_CALLABLE_EX_r55] = "_CHECK_IS_PY_CALLABLE_EX_r55", [_CHECK_MANAGED_OBJECT_HAS_VALUES] = "_CHECK_MANAGED_OBJECT_HAS_VALUES", [_CHECK_MANAGED_OBJECT_HAS_VALUES_r01] = "_CHECK_MANAGED_OBJECT_HAS_VALUES_r01", [_CHECK_MANAGED_OBJECT_HAS_VALUES_r11] = "_CHECK_MANAGED_OBJECT_HAS_VALUES_r11", [_CHECK_MANAGED_OBJECT_HAS_VALUES_r22] = "_CHECK_MANAGED_OBJECT_HAS_VALUES_r22", [_CHECK_MANAGED_OBJECT_HAS_VALUES_r33] = "_CHECK_MANAGED_OBJECT_HAS_VALUES_r33", + [_CHECK_MANAGED_OBJECT_HAS_VALUES_r44] = "_CHECK_MANAGED_OBJECT_HAS_VALUES_r44", + [_CHECK_MANAGED_OBJECT_HAS_VALUES_r55] = "_CHECK_MANAGED_OBJECT_HAS_VALUES_r55", [_CHECK_METHOD_VERSION] = "_CHECK_METHOD_VERSION", [_CHECK_METHOD_VERSION_r00] = "_CHECK_METHOD_VERSION_r00", [_CHECK_METHOD_VERSION_KW] = "_CHECK_METHOD_VERSION_KW", @@ -4503,6 +4897,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CHECK_PEP_523_r11] = "_CHECK_PEP_523_r11", [_CHECK_PEP_523_r22] = "_CHECK_PEP_523_r22", [_CHECK_PEP_523_r33] = "_CHECK_PEP_523_r33", + [_CHECK_PEP_523_r44] = "_CHECK_PEP_523_r44", + [_CHECK_PEP_523_r55] = "_CHECK_PEP_523_r55", [_CHECK_PERIODIC] = "_CHECK_PERIODIC", [_CHECK_PERIODIC_r00] = "_CHECK_PERIODIC_r00", [_CHECK_PERIODIC_IF_NOT_YIELD_FROM] = "_CHECK_PERIODIC_IF_NOT_YIELD_FROM", @@ -4512,6 +4908,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CHECK_RECURSION_REMAINING_r11] = "_CHECK_RECURSION_REMAINING_r11", [_CHECK_RECURSION_REMAINING_r22] = "_CHECK_RECURSION_REMAINING_r22", [_CHECK_RECURSION_REMAINING_r33] = "_CHECK_RECURSION_REMAINING_r33", + [_CHECK_RECURSION_REMAINING_r44] = "_CHECK_RECURSION_REMAINING_r44", + [_CHECK_RECURSION_REMAINING_r55] = "_CHECK_RECURSION_REMAINING_r55", [_CHECK_STACK_SPACE] = "_CHECK_STACK_SPACE", [_CHECK_STACK_SPACE_r00] = "_CHECK_STACK_SPACE_r00", [_CHECK_STACK_SPACE_OPERAND] = "_CHECK_STACK_SPACE_OPERAND", @@ -4519,11 +4917,15 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_CHECK_STACK_SPACE_OPERAND_r11] = "_CHECK_STACK_SPACE_OPERAND_r11", [_CHECK_STACK_SPACE_OPERAND_r22] = "_CHECK_STACK_SPACE_OPERAND_r22", [_CHECK_STACK_SPACE_OPERAND_r33] = "_CHECK_STACK_SPACE_OPERAND_r33", + [_CHECK_STACK_SPACE_OPERAND_r44] = "_CHECK_STACK_SPACE_OPERAND_r44", + [_CHECK_STACK_SPACE_OPERAND_r55] = "_CHECK_STACK_SPACE_OPERAND_r55", [_CHECK_VALIDITY] = "_CHECK_VALIDITY", [_CHECK_VALIDITY_r00] = "_CHECK_VALIDITY_r00", [_CHECK_VALIDITY_r11] = "_CHECK_VALIDITY_r11", [_CHECK_VALIDITY_r22] = "_CHECK_VALIDITY_r22", [_CHECK_VALIDITY_r33] = "_CHECK_VALIDITY_r33", + [_CHECK_VALIDITY_r44] = "_CHECK_VALIDITY_r44", + [_CHECK_VALIDITY_r55] = "_CHECK_VALIDITY_r55", [_COLD_DYNAMIC_EXIT] = "_COLD_DYNAMIC_EXIT", [_COLD_DYNAMIC_EXIT_r00] = "_COLD_DYNAMIC_EXIT_r00", [_COLD_EXIT] = "_COLD_EXIT", @@ -4534,6 +4936,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_COMPARE_OP_FLOAT_r03] = "_COMPARE_OP_FLOAT_r03", [_COMPARE_OP_FLOAT_r13] = "_COMPARE_OP_FLOAT_r13", [_COMPARE_OP_FLOAT_r23] = "_COMPARE_OP_FLOAT_r23", + [_COMPARE_OP_FLOAT_r34] = "_COMPARE_OP_FLOAT_r34", + [_COMPARE_OP_FLOAT_r45] = "_COMPARE_OP_FLOAT_r45", [_COMPARE_OP_INT] = "_COMPARE_OP_INT", [_COMPARE_OP_INT_r23] = "_COMPARE_OP_INT_r23", [_COMPARE_OP_STR] = "_COMPARE_OP_STR", @@ -4552,20 +4956,27 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_COPY_1_r02] = "_COPY_1_r02", [_COPY_1_r12] = "_COPY_1_r12", [_COPY_1_r23] = "_COPY_1_r23", + [_COPY_1_r34] = "_COPY_1_r34", + [_COPY_1_r45] = "_COPY_1_r45", [_COPY_2] = "_COPY_2", [_COPY_2_r03] = "_COPY_2_r03", [_COPY_2_r13] = "_COPY_2_r13", [_COPY_2_r23] = "_COPY_2_r23", + [_COPY_2_r34] = "_COPY_2_r34", + [_COPY_2_r45] = "_COPY_2_r45", [_COPY_3] = "_COPY_3", - [_COPY_3_r03] = "_COPY_3_r03", - [_COPY_3_r13] = "_COPY_3_r13", - [_COPY_3_r23] = "_COPY_3_r23", - [_COPY_3_r33] = "_COPY_3_r33", + [_COPY_3_r04] = "_COPY_3_r04", + [_COPY_3_r14] = "_COPY_3_r14", + [_COPY_3_r24] = "_COPY_3_r24", + [_COPY_3_r34] = "_COPY_3_r34", + [_COPY_3_r45] = "_COPY_3_r45", [_COPY_FREE_VARS] = "_COPY_FREE_VARS", [_COPY_FREE_VARS_r00] = "_COPY_FREE_VARS_r00", [_COPY_FREE_VARS_r11] = "_COPY_FREE_VARS_r11", [_COPY_FREE_VARS_r22] = "_COPY_FREE_VARS_r22", [_COPY_FREE_VARS_r33] = "_COPY_FREE_VARS_r33", + [_COPY_FREE_VARS_r44] = "_COPY_FREE_VARS_r44", + [_COPY_FREE_VARS_r55] = "_COPY_FREE_VARS_r55", [_CREATE_INIT_FRAME] = "_CREATE_INIT_FRAME", [_CREATE_INIT_FRAME_r01] = "_CREATE_INIT_FRAME_r01", [_DELETE_ATTR] = "_DELETE_ATTR", @@ -4585,6 +4996,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_DEOPT_r10] = "_DEOPT_r10", [_DEOPT_r20] = "_DEOPT_r20", [_DEOPT_r30] = "_DEOPT_r30", + [_DEOPT_r40] = "_DEOPT_r40", + [_DEOPT_r50] = "_DEOPT_r50", [_DICT_MERGE] = "_DICT_MERGE", [_DICT_MERGE_r10] = "_DICT_MERGE_r10", [_DICT_UPDATE] = "_DICT_UPDATE", @@ -4594,6 +5007,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_DYNAMIC_EXIT_r10] = "_DYNAMIC_EXIT_r10", [_DYNAMIC_EXIT_r20] = "_DYNAMIC_EXIT_r20", [_DYNAMIC_EXIT_r30] = "_DYNAMIC_EXIT_r30", + [_DYNAMIC_EXIT_r40] = "_DYNAMIC_EXIT_r40", + [_DYNAMIC_EXIT_r50] = "_DYNAMIC_EXIT_r50", [_END_FOR] = "_END_FOR", [_END_FOR_r10] = "_END_FOR_r10", [_END_SEND] = "_END_SEND", @@ -4607,6 +5022,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_EXIT_TRACE_r10] = "_EXIT_TRACE_r10", [_EXIT_TRACE_r20] = "_EXIT_TRACE_r20", [_EXIT_TRACE_r30] = "_EXIT_TRACE_r30", + [_EXIT_TRACE_r40] = "_EXIT_TRACE_r40", + [_EXIT_TRACE_r50] = "_EXIT_TRACE_r50", [_EXPAND_METHOD] = "_EXPAND_METHOD", [_EXPAND_METHOD_r00] = "_EXPAND_METHOD_r00", [_EXPAND_METHOD_KW] = "_EXPAND_METHOD_KW", @@ -4616,6 +5033,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_FATAL_ERROR_r11] = "_FATAL_ERROR_r11", [_FATAL_ERROR_r22] = "_FATAL_ERROR_r22", [_FATAL_ERROR_r33] = "_FATAL_ERROR_r33", + [_FATAL_ERROR_r44] = "_FATAL_ERROR_r44", + [_FATAL_ERROR_r55] = "_FATAL_ERROR_r55", [_FORMAT_SIMPLE] = "_FORMAT_SIMPLE", [_FORMAT_SIMPLE_r11] = "_FORMAT_SIMPLE_r11", [_FORMAT_WITH_SPEC] = "_FORMAT_WITH_SPEC", @@ -4624,6 +5043,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_FOR_ITER_GEN_FRAME_r03] = "_FOR_ITER_GEN_FRAME_r03", [_FOR_ITER_GEN_FRAME_r13] = "_FOR_ITER_GEN_FRAME_r13", [_FOR_ITER_GEN_FRAME_r23] = "_FOR_ITER_GEN_FRAME_r23", + [_FOR_ITER_GEN_FRAME_r34] = "_FOR_ITER_GEN_FRAME_r34", + [_FOR_ITER_GEN_FRAME_r45] = "_FOR_ITER_GEN_FRAME_r45", [_FOR_ITER_TIER_TWO] = "_FOR_ITER_TIER_TWO", [_FOR_ITER_TIER_TWO_r23] = "_FOR_ITER_TIER_TWO_r23", [_GET_AITER] = "_GET_AITER", @@ -4645,136 +5066,190 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12] = "_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12", [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22] = "_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22", [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33] = "_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33", + [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r44] = "_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r44", + [_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r55] = "_GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r55", [_GUARD_BIT_IS_SET_POP] = "_GUARD_BIT_IS_SET_POP", [_GUARD_BIT_IS_SET_POP_r00] = "_GUARD_BIT_IS_SET_POP_r00", [_GUARD_BIT_IS_SET_POP_r10] = "_GUARD_BIT_IS_SET_POP_r10", [_GUARD_BIT_IS_SET_POP_r21] = "_GUARD_BIT_IS_SET_POP_r21", [_GUARD_BIT_IS_SET_POP_r32] = "_GUARD_BIT_IS_SET_POP_r32", + [_GUARD_BIT_IS_SET_POP_r43] = "_GUARD_BIT_IS_SET_POP_r43", + [_GUARD_BIT_IS_SET_POP_r54] = "_GUARD_BIT_IS_SET_POP_r54", [_GUARD_BIT_IS_SET_POP_4] = "_GUARD_BIT_IS_SET_POP_4", [_GUARD_BIT_IS_SET_POP_4_r00] = "_GUARD_BIT_IS_SET_POP_4_r00", [_GUARD_BIT_IS_SET_POP_4_r10] = "_GUARD_BIT_IS_SET_POP_4_r10", [_GUARD_BIT_IS_SET_POP_4_r21] = "_GUARD_BIT_IS_SET_POP_4_r21", [_GUARD_BIT_IS_SET_POP_4_r32] = "_GUARD_BIT_IS_SET_POP_4_r32", + [_GUARD_BIT_IS_SET_POP_4_r43] = "_GUARD_BIT_IS_SET_POP_4_r43", + [_GUARD_BIT_IS_SET_POP_4_r54] = "_GUARD_BIT_IS_SET_POP_4_r54", [_GUARD_BIT_IS_SET_POP_5] = "_GUARD_BIT_IS_SET_POP_5", [_GUARD_BIT_IS_SET_POP_5_r00] = "_GUARD_BIT_IS_SET_POP_5_r00", [_GUARD_BIT_IS_SET_POP_5_r10] = "_GUARD_BIT_IS_SET_POP_5_r10", [_GUARD_BIT_IS_SET_POP_5_r21] = "_GUARD_BIT_IS_SET_POP_5_r21", [_GUARD_BIT_IS_SET_POP_5_r32] = "_GUARD_BIT_IS_SET_POP_5_r32", + [_GUARD_BIT_IS_SET_POP_5_r43] = "_GUARD_BIT_IS_SET_POP_5_r43", + [_GUARD_BIT_IS_SET_POP_5_r54] = "_GUARD_BIT_IS_SET_POP_5_r54", [_GUARD_BIT_IS_SET_POP_6] = "_GUARD_BIT_IS_SET_POP_6", [_GUARD_BIT_IS_SET_POP_6_r00] = "_GUARD_BIT_IS_SET_POP_6_r00", [_GUARD_BIT_IS_SET_POP_6_r10] = "_GUARD_BIT_IS_SET_POP_6_r10", [_GUARD_BIT_IS_SET_POP_6_r21] = "_GUARD_BIT_IS_SET_POP_6_r21", [_GUARD_BIT_IS_SET_POP_6_r32] = "_GUARD_BIT_IS_SET_POP_6_r32", + [_GUARD_BIT_IS_SET_POP_6_r43] = "_GUARD_BIT_IS_SET_POP_6_r43", + [_GUARD_BIT_IS_SET_POP_6_r54] = "_GUARD_BIT_IS_SET_POP_6_r54", [_GUARD_BIT_IS_SET_POP_7] = "_GUARD_BIT_IS_SET_POP_7", [_GUARD_BIT_IS_SET_POP_7_r00] = "_GUARD_BIT_IS_SET_POP_7_r00", [_GUARD_BIT_IS_SET_POP_7_r10] = "_GUARD_BIT_IS_SET_POP_7_r10", [_GUARD_BIT_IS_SET_POP_7_r21] = "_GUARD_BIT_IS_SET_POP_7_r21", [_GUARD_BIT_IS_SET_POP_7_r32] = "_GUARD_BIT_IS_SET_POP_7_r32", + [_GUARD_BIT_IS_SET_POP_7_r43] = "_GUARD_BIT_IS_SET_POP_7_r43", + [_GUARD_BIT_IS_SET_POP_7_r54] = "_GUARD_BIT_IS_SET_POP_7_r54", [_GUARD_BIT_IS_UNSET_POP] = "_GUARD_BIT_IS_UNSET_POP", [_GUARD_BIT_IS_UNSET_POP_r00] = "_GUARD_BIT_IS_UNSET_POP_r00", [_GUARD_BIT_IS_UNSET_POP_r10] = "_GUARD_BIT_IS_UNSET_POP_r10", [_GUARD_BIT_IS_UNSET_POP_r21] = "_GUARD_BIT_IS_UNSET_POP_r21", [_GUARD_BIT_IS_UNSET_POP_r32] = "_GUARD_BIT_IS_UNSET_POP_r32", + [_GUARD_BIT_IS_UNSET_POP_r43] = "_GUARD_BIT_IS_UNSET_POP_r43", + [_GUARD_BIT_IS_UNSET_POP_r54] = "_GUARD_BIT_IS_UNSET_POP_r54", [_GUARD_BIT_IS_UNSET_POP_4] = "_GUARD_BIT_IS_UNSET_POP_4", [_GUARD_BIT_IS_UNSET_POP_4_r00] = "_GUARD_BIT_IS_UNSET_POP_4_r00", [_GUARD_BIT_IS_UNSET_POP_4_r10] = "_GUARD_BIT_IS_UNSET_POP_4_r10", [_GUARD_BIT_IS_UNSET_POP_4_r21] = "_GUARD_BIT_IS_UNSET_POP_4_r21", [_GUARD_BIT_IS_UNSET_POP_4_r32] = "_GUARD_BIT_IS_UNSET_POP_4_r32", + [_GUARD_BIT_IS_UNSET_POP_4_r43] = "_GUARD_BIT_IS_UNSET_POP_4_r43", + [_GUARD_BIT_IS_UNSET_POP_4_r54] = "_GUARD_BIT_IS_UNSET_POP_4_r54", [_GUARD_BIT_IS_UNSET_POP_5] = "_GUARD_BIT_IS_UNSET_POP_5", [_GUARD_BIT_IS_UNSET_POP_5_r00] = "_GUARD_BIT_IS_UNSET_POP_5_r00", [_GUARD_BIT_IS_UNSET_POP_5_r10] = "_GUARD_BIT_IS_UNSET_POP_5_r10", [_GUARD_BIT_IS_UNSET_POP_5_r21] = "_GUARD_BIT_IS_UNSET_POP_5_r21", [_GUARD_BIT_IS_UNSET_POP_5_r32] = "_GUARD_BIT_IS_UNSET_POP_5_r32", + [_GUARD_BIT_IS_UNSET_POP_5_r43] = "_GUARD_BIT_IS_UNSET_POP_5_r43", + [_GUARD_BIT_IS_UNSET_POP_5_r54] = "_GUARD_BIT_IS_UNSET_POP_5_r54", [_GUARD_BIT_IS_UNSET_POP_6] = "_GUARD_BIT_IS_UNSET_POP_6", [_GUARD_BIT_IS_UNSET_POP_6_r00] = "_GUARD_BIT_IS_UNSET_POP_6_r00", [_GUARD_BIT_IS_UNSET_POP_6_r10] = "_GUARD_BIT_IS_UNSET_POP_6_r10", [_GUARD_BIT_IS_UNSET_POP_6_r21] = "_GUARD_BIT_IS_UNSET_POP_6_r21", [_GUARD_BIT_IS_UNSET_POP_6_r32] = "_GUARD_BIT_IS_UNSET_POP_6_r32", + [_GUARD_BIT_IS_UNSET_POP_6_r43] = "_GUARD_BIT_IS_UNSET_POP_6_r43", + [_GUARD_BIT_IS_UNSET_POP_6_r54] = "_GUARD_BIT_IS_UNSET_POP_6_r54", [_GUARD_BIT_IS_UNSET_POP_7] = "_GUARD_BIT_IS_UNSET_POP_7", [_GUARD_BIT_IS_UNSET_POP_7_r00] = "_GUARD_BIT_IS_UNSET_POP_7_r00", [_GUARD_BIT_IS_UNSET_POP_7_r10] = "_GUARD_BIT_IS_UNSET_POP_7_r10", [_GUARD_BIT_IS_UNSET_POP_7_r21] = "_GUARD_BIT_IS_UNSET_POP_7_r21", [_GUARD_BIT_IS_UNSET_POP_7_r32] = "_GUARD_BIT_IS_UNSET_POP_7_r32", + [_GUARD_BIT_IS_UNSET_POP_7_r43] = "_GUARD_BIT_IS_UNSET_POP_7_r43", + [_GUARD_BIT_IS_UNSET_POP_7_r54] = "_GUARD_BIT_IS_UNSET_POP_7_r54", [_GUARD_CALLABLE_ISINSTANCE] = "_GUARD_CALLABLE_ISINSTANCE", - [_GUARD_CALLABLE_ISINSTANCE_r03] = "_GUARD_CALLABLE_ISINSTANCE_r03", - [_GUARD_CALLABLE_ISINSTANCE_r13] = "_GUARD_CALLABLE_ISINSTANCE_r13", - [_GUARD_CALLABLE_ISINSTANCE_r23] = "_GUARD_CALLABLE_ISINSTANCE_r23", - [_GUARD_CALLABLE_ISINSTANCE_r33] = "_GUARD_CALLABLE_ISINSTANCE_r33", + [_GUARD_CALLABLE_ISINSTANCE_r04] = "_GUARD_CALLABLE_ISINSTANCE_r04", + [_GUARD_CALLABLE_ISINSTANCE_r14] = "_GUARD_CALLABLE_ISINSTANCE_r14", + [_GUARD_CALLABLE_ISINSTANCE_r24] = "_GUARD_CALLABLE_ISINSTANCE_r24", + [_GUARD_CALLABLE_ISINSTANCE_r34] = "_GUARD_CALLABLE_ISINSTANCE_r34", + [_GUARD_CALLABLE_ISINSTANCE_r44] = "_GUARD_CALLABLE_ISINSTANCE_r44", + [_GUARD_CALLABLE_ISINSTANCE_r55] = "_GUARD_CALLABLE_ISINSTANCE_r55", [_GUARD_CALLABLE_LEN] = "_GUARD_CALLABLE_LEN", [_GUARD_CALLABLE_LEN_r03] = "_GUARD_CALLABLE_LEN_r03", [_GUARD_CALLABLE_LEN_r13] = "_GUARD_CALLABLE_LEN_r13", [_GUARD_CALLABLE_LEN_r23] = "_GUARD_CALLABLE_LEN_r23", [_GUARD_CALLABLE_LEN_r33] = "_GUARD_CALLABLE_LEN_r33", + [_GUARD_CALLABLE_LEN_r44] = "_GUARD_CALLABLE_LEN_r44", + [_GUARD_CALLABLE_LEN_r55] = "_GUARD_CALLABLE_LEN_r55", [_GUARD_CALLABLE_LIST_APPEND] = "_GUARD_CALLABLE_LIST_APPEND", [_GUARD_CALLABLE_LIST_APPEND_r03] = "_GUARD_CALLABLE_LIST_APPEND_r03", [_GUARD_CALLABLE_LIST_APPEND_r13] = "_GUARD_CALLABLE_LIST_APPEND_r13", [_GUARD_CALLABLE_LIST_APPEND_r23] = "_GUARD_CALLABLE_LIST_APPEND_r23", [_GUARD_CALLABLE_LIST_APPEND_r33] = "_GUARD_CALLABLE_LIST_APPEND_r33", + [_GUARD_CALLABLE_LIST_APPEND_r44] = "_GUARD_CALLABLE_LIST_APPEND_r44", + [_GUARD_CALLABLE_LIST_APPEND_r55] = "_GUARD_CALLABLE_LIST_APPEND_r55", [_GUARD_CALLABLE_STR_1] = "_GUARD_CALLABLE_STR_1", [_GUARD_CALLABLE_STR_1_r03] = "_GUARD_CALLABLE_STR_1_r03", [_GUARD_CALLABLE_STR_1_r13] = "_GUARD_CALLABLE_STR_1_r13", [_GUARD_CALLABLE_STR_1_r23] = "_GUARD_CALLABLE_STR_1_r23", [_GUARD_CALLABLE_STR_1_r33] = "_GUARD_CALLABLE_STR_1_r33", + [_GUARD_CALLABLE_STR_1_r44] = "_GUARD_CALLABLE_STR_1_r44", + [_GUARD_CALLABLE_STR_1_r55] = "_GUARD_CALLABLE_STR_1_r55", [_GUARD_CALLABLE_TUPLE_1] = "_GUARD_CALLABLE_TUPLE_1", [_GUARD_CALLABLE_TUPLE_1_r03] = "_GUARD_CALLABLE_TUPLE_1_r03", [_GUARD_CALLABLE_TUPLE_1_r13] = "_GUARD_CALLABLE_TUPLE_1_r13", [_GUARD_CALLABLE_TUPLE_1_r23] = "_GUARD_CALLABLE_TUPLE_1_r23", [_GUARD_CALLABLE_TUPLE_1_r33] = "_GUARD_CALLABLE_TUPLE_1_r33", + [_GUARD_CALLABLE_TUPLE_1_r44] = "_GUARD_CALLABLE_TUPLE_1_r44", + [_GUARD_CALLABLE_TUPLE_1_r55] = "_GUARD_CALLABLE_TUPLE_1_r55", [_GUARD_CALLABLE_TYPE_1] = "_GUARD_CALLABLE_TYPE_1", [_GUARD_CALLABLE_TYPE_1_r03] = "_GUARD_CALLABLE_TYPE_1_r03", [_GUARD_CALLABLE_TYPE_1_r13] = "_GUARD_CALLABLE_TYPE_1_r13", [_GUARD_CALLABLE_TYPE_1_r23] = "_GUARD_CALLABLE_TYPE_1_r23", [_GUARD_CALLABLE_TYPE_1_r33] = "_GUARD_CALLABLE_TYPE_1_r33", + [_GUARD_CALLABLE_TYPE_1_r44] = "_GUARD_CALLABLE_TYPE_1_r44", + [_GUARD_CALLABLE_TYPE_1_r55] = "_GUARD_CALLABLE_TYPE_1_r55", [_GUARD_CODE_VERSION] = "_GUARD_CODE_VERSION", [_GUARD_CODE_VERSION_r00] = "_GUARD_CODE_VERSION_r00", [_GUARD_CODE_VERSION_r11] = "_GUARD_CODE_VERSION_r11", [_GUARD_CODE_VERSION_r22] = "_GUARD_CODE_VERSION_r22", [_GUARD_CODE_VERSION_r33] = "_GUARD_CODE_VERSION_r33", + [_GUARD_CODE_VERSION_r44] = "_GUARD_CODE_VERSION_r44", + [_GUARD_CODE_VERSION_r55] = "_GUARD_CODE_VERSION_r55", [_GUARD_DORV_NO_DICT] = "_GUARD_DORV_NO_DICT", [_GUARD_DORV_NO_DICT_r01] = "_GUARD_DORV_NO_DICT_r01", [_GUARD_DORV_NO_DICT_r11] = "_GUARD_DORV_NO_DICT_r11", [_GUARD_DORV_NO_DICT_r22] = "_GUARD_DORV_NO_DICT_r22", [_GUARD_DORV_NO_DICT_r33] = "_GUARD_DORV_NO_DICT_r33", + [_GUARD_DORV_NO_DICT_r44] = "_GUARD_DORV_NO_DICT_r44", + [_GUARD_DORV_NO_DICT_r55] = "_GUARD_DORV_NO_DICT_r55", [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT", [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01", [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11", [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22", [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33", + [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r44] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r44", + [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r55] = "_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r55", [_GUARD_GLOBALS_VERSION] = "_GUARD_GLOBALS_VERSION", [_GUARD_GLOBALS_VERSION_r00] = "_GUARD_GLOBALS_VERSION_r00", [_GUARD_GLOBALS_VERSION_r11] = "_GUARD_GLOBALS_VERSION_r11", [_GUARD_GLOBALS_VERSION_r22] = "_GUARD_GLOBALS_VERSION_r22", [_GUARD_GLOBALS_VERSION_r33] = "_GUARD_GLOBALS_VERSION_r33", + [_GUARD_GLOBALS_VERSION_r44] = "_GUARD_GLOBALS_VERSION_r44", + [_GUARD_GLOBALS_VERSION_r55] = "_GUARD_GLOBALS_VERSION_r55", [_GUARD_IP_RETURN_GENERATOR] = "_GUARD_IP_RETURN_GENERATOR", [_GUARD_IP_RETURN_GENERATOR_r00] = "_GUARD_IP_RETURN_GENERATOR_r00", [_GUARD_IP_RETURN_GENERATOR_r11] = "_GUARD_IP_RETURN_GENERATOR_r11", [_GUARD_IP_RETURN_GENERATOR_r22] = "_GUARD_IP_RETURN_GENERATOR_r22", [_GUARD_IP_RETURN_GENERATOR_r33] = "_GUARD_IP_RETURN_GENERATOR_r33", + [_GUARD_IP_RETURN_GENERATOR_r44] = "_GUARD_IP_RETURN_GENERATOR_r44", + [_GUARD_IP_RETURN_GENERATOR_r55] = "_GUARD_IP_RETURN_GENERATOR_r55", [_GUARD_IP_RETURN_VALUE] = "_GUARD_IP_RETURN_VALUE", [_GUARD_IP_RETURN_VALUE_r00] = "_GUARD_IP_RETURN_VALUE_r00", [_GUARD_IP_RETURN_VALUE_r11] = "_GUARD_IP_RETURN_VALUE_r11", [_GUARD_IP_RETURN_VALUE_r22] = "_GUARD_IP_RETURN_VALUE_r22", [_GUARD_IP_RETURN_VALUE_r33] = "_GUARD_IP_RETURN_VALUE_r33", + [_GUARD_IP_RETURN_VALUE_r44] = "_GUARD_IP_RETURN_VALUE_r44", + [_GUARD_IP_RETURN_VALUE_r55] = "_GUARD_IP_RETURN_VALUE_r55", [_GUARD_IP_YIELD_VALUE] = "_GUARD_IP_YIELD_VALUE", [_GUARD_IP_YIELD_VALUE_r00] = "_GUARD_IP_YIELD_VALUE_r00", [_GUARD_IP_YIELD_VALUE_r11] = "_GUARD_IP_YIELD_VALUE_r11", [_GUARD_IP_YIELD_VALUE_r22] = "_GUARD_IP_YIELD_VALUE_r22", [_GUARD_IP_YIELD_VALUE_r33] = "_GUARD_IP_YIELD_VALUE_r33", + [_GUARD_IP_YIELD_VALUE_r44] = "_GUARD_IP_YIELD_VALUE_r44", + [_GUARD_IP_YIELD_VALUE_r55] = "_GUARD_IP_YIELD_VALUE_r55", [_GUARD_IP__PUSH_FRAME] = "_GUARD_IP__PUSH_FRAME", [_GUARD_IP__PUSH_FRAME_r00] = "_GUARD_IP__PUSH_FRAME_r00", [_GUARD_IP__PUSH_FRAME_r11] = "_GUARD_IP__PUSH_FRAME_r11", [_GUARD_IP__PUSH_FRAME_r22] = "_GUARD_IP__PUSH_FRAME_r22", [_GUARD_IP__PUSH_FRAME_r33] = "_GUARD_IP__PUSH_FRAME_r33", + [_GUARD_IP__PUSH_FRAME_r44] = "_GUARD_IP__PUSH_FRAME_r44", + [_GUARD_IP__PUSH_FRAME_r55] = "_GUARD_IP__PUSH_FRAME_r55", [_GUARD_IS_FALSE_POP] = "_GUARD_IS_FALSE_POP", [_GUARD_IS_FALSE_POP_r00] = "_GUARD_IS_FALSE_POP_r00", [_GUARD_IS_FALSE_POP_r10] = "_GUARD_IS_FALSE_POP_r10", [_GUARD_IS_FALSE_POP_r21] = "_GUARD_IS_FALSE_POP_r21", [_GUARD_IS_FALSE_POP_r32] = "_GUARD_IS_FALSE_POP_r32", + [_GUARD_IS_FALSE_POP_r43] = "_GUARD_IS_FALSE_POP_r43", + [_GUARD_IS_FALSE_POP_r54] = "_GUARD_IS_FALSE_POP_r54", [_GUARD_IS_NONE_POP] = "_GUARD_IS_NONE_POP", [_GUARD_IS_NONE_POP_r00] = "_GUARD_IS_NONE_POP_r00", [_GUARD_IS_NONE_POP_r10] = "_GUARD_IS_NONE_POP_r10", [_GUARD_IS_NONE_POP_r21] = "_GUARD_IS_NONE_POP_r21", [_GUARD_IS_NONE_POP_r32] = "_GUARD_IS_NONE_POP_r32", + [_GUARD_IS_NONE_POP_r43] = "_GUARD_IS_NONE_POP_r43", + [_GUARD_IS_NONE_POP_r54] = "_GUARD_IS_NONE_POP_r54", [_GUARD_IS_NOT_NONE_POP] = "_GUARD_IS_NOT_NONE_POP", [_GUARD_IS_NOT_NONE_POP_r10] = "_GUARD_IS_NOT_NONE_POP_r10", [_GUARD_IS_TRUE_POP] = "_GUARD_IS_TRUE_POP", @@ -4782,166 +5257,232 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_GUARD_IS_TRUE_POP_r10] = "_GUARD_IS_TRUE_POP_r10", [_GUARD_IS_TRUE_POP_r21] = "_GUARD_IS_TRUE_POP_r21", [_GUARD_IS_TRUE_POP_r32] = "_GUARD_IS_TRUE_POP_r32", + [_GUARD_IS_TRUE_POP_r43] = "_GUARD_IS_TRUE_POP_r43", + [_GUARD_IS_TRUE_POP_r54] = "_GUARD_IS_TRUE_POP_r54", [_GUARD_KEYS_VERSION] = "_GUARD_KEYS_VERSION", [_GUARD_KEYS_VERSION_r01] = "_GUARD_KEYS_VERSION_r01", [_GUARD_KEYS_VERSION_r11] = "_GUARD_KEYS_VERSION_r11", [_GUARD_KEYS_VERSION_r22] = "_GUARD_KEYS_VERSION_r22", [_GUARD_KEYS_VERSION_r33] = "_GUARD_KEYS_VERSION_r33", + [_GUARD_KEYS_VERSION_r44] = "_GUARD_KEYS_VERSION_r44", + [_GUARD_KEYS_VERSION_r55] = "_GUARD_KEYS_VERSION_r55", [_GUARD_NOS_ANY_DICT] = "_GUARD_NOS_ANY_DICT", [_GUARD_NOS_ANY_DICT_r02] = "_GUARD_NOS_ANY_DICT_r02", [_GUARD_NOS_ANY_DICT_r12] = "_GUARD_NOS_ANY_DICT_r12", [_GUARD_NOS_ANY_DICT_r22] = "_GUARD_NOS_ANY_DICT_r22", [_GUARD_NOS_ANY_DICT_r33] = "_GUARD_NOS_ANY_DICT_r33", + [_GUARD_NOS_ANY_DICT_r44] = "_GUARD_NOS_ANY_DICT_r44", + [_GUARD_NOS_ANY_DICT_r55] = "_GUARD_NOS_ANY_DICT_r55", [_GUARD_NOS_COMPACT_ASCII] = "_GUARD_NOS_COMPACT_ASCII", [_GUARD_NOS_COMPACT_ASCII_r02] = "_GUARD_NOS_COMPACT_ASCII_r02", [_GUARD_NOS_COMPACT_ASCII_r12] = "_GUARD_NOS_COMPACT_ASCII_r12", [_GUARD_NOS_COMPACT_ASCII_r22] = "_GUARD_NOS_COMPACT_ASCII_r22", [_GUARD_NOS_COMPACT_ASCII_r33] = "_GUARD_NOS_COMPACT_ASCII_r33", + [_GUARD_NOS_COMPACT_ASCII_r44] = "_GUARD_NOS_COMPACT_ASCII_r44", + [_GUARD_NOS_COMPACT_ASCII_r55] = "_GUARD_NOS_COMPACT_ASCII_r55", [_GUARD_NOS_DICT] = "_GUARD_NOS_DICT", [_GUARD_NOS_DICT_r02] = "_GUARD_NOS_DICT_r02", [_GUARD_NOS_DICT_r12] = "_GUARD_NOS_DICT_r12", [_GUARD_NOS_DICT_r22] = "_GUARD_NOS_DICT_r22", [_GUARD_NOS_DICT_r33] = "_GUARD_NOS_DICT_r33", + [_GUARD_NOS_DICT_r44] = "_GUARD_NOS_DICT_r44", + [_GUARD_NOS_DICT_r55] = "_GUARD_NOS_DICT_r55", [_GUARD_NOS_FLOAT] = "_GUARD_NOS_FLOAT", [_GUARD_NOS_FLOAT_r02] = "_GUARD_NOS_FLOAT_r02", [_GUARD_NOS_FLOAT_r12] = "_GUARD_NOS_FLOAT_r12", [_GUARD_NOS_FLOAT_r22] = "_GUARD_NOS_FLOAT_r22", [_GUARD_NOS_FLOAT_r33] = "_GUARD_NOS_FLOAT_r33", + [_GUARD_NOS_FLOAT_r44] = "_GUARD_NOS_FLOAT_r44", + [_GUARD_NOS_FLOAT_r55] = "_GUARD_NOS_FLOAT_r55", [_GUARD_NOS_INT] = "_GUARD_NOS_INT", [_GUARD_NOS_INT_r02] = "_GUARD_NOS_INT_r02", [_GUARD_NOS_INT_r12] = "_GUARD_NOS_INT_r12", [_GUARD_NOS_INT_r22] = "_GUARD_NOS_INT_r22", [_GUARD_NOS_INT_r33] = "_GUARD_NOS_INT_r33", + [_GUARD_NOS_INT_r44] = "_GUARD_NOS_INT_r44", + [_GUARD_NOS_INT_r55] = "_GUARD_NOS_INT_r55", [_GUARD_NOS_LIST] = "_GUARD_NOS_LIST", [_GUARD_NOS_LIST_r02] = "_GUARD_NOS_LIST_r02", [_GUARD_NOS_LIST_r12] = "_GUARD_NOS_LIST_r12", [_GUARD_NOS_LIST_r22] = "_GUARD_NOS_LIST_r22", [_GUARD_NOS_LIST_r33] = "_GUARD_NOS_LIST_r33", + [_GUARD_NOS_LIST_r44] = "_GUARD_NOS_LIST_r44", + [_GUARD_NOS_LIST_r55] = "_GUARD_NOS_LIST_r55", [_GUARD_NOS_NOT_NULL] = "_GUARD_NOS_NOT_NULL", [_GUARD_NOS_NOT_NULL_r02] = "_GUARD_NOS_NOT_NULL_r02", [_GUARD_NOS_NOT_NULL_r12] = "_GUARD_NOS_NOT_NULL_r12", [_GUARD_NOS_NOT_NULL_r22] = "_GUARD_NOS_NOT_NULL_r22", [_GUARD_NOS_NOT_NULL_r33] = "_GUARD_NOS_NOT_NULL_r33", + [_GUARD_NOS_NOT_NULL_r44] = "_GUARD_NOS_NOT_NULL_r44", + [_GUARD_NOS_NOT_NULL_r55] = "_GUARD_NOS_NOT_NULL_r55", [_GUARD_NOS_NULL] = "_GUARD_NOS_NULL", [_GUARD_NOS_NULL_r02] = "_GUARD_NOS_NULL_r02", [_GUARD_NOS_NULL_r12] = "_GUARD_NOS_NULL_r12", [_GUARD_NOS_NULL_r22] = "_GUARD_NOS_NULL_r22", [_GUARD_NOS_NULL_r33] = "_GUARD_NOS_NULL_r33", + [_GUARD_NOS_NULL_r44] = "_GUARD_NOS_NULL_r44", + [_GUARD_NOS_NULL_r55] = "_GUARD_NOS_NULL_r55", [_GUARD_NOS_OVERFLOWED] = "_GUARD_NOS_OVERFLOWED", [_GUARD_NOS_OVERFLOWED_r02] = "_GUARD_NOS_OVERFLOWED_r02", [_GUARD_NOS_OVERFLOWED_r12] = "_GUARD_NOS_OVERFLOWED_r12", [_GUARD_NOS_OVERFLOWED_r22] = "_GUARD_NOS_OVERFLOWED_r22", [_GUARD_NOS_OVERFLOWED_r33] = "_GUARD_NOS_OVERFLOWED_r33", + [_GUARD_NOS_OVERFLOWED_r44] = "_GUARD_NOS_OVERFLOWED_r44", + [_GUARD_NOS_OVERFLOWED_r55] = "_GUARD_NOS_OVERFLOWED_r55", [_GUARD_NOS_TUPLE] = "_GUARD_NOS_TUPLE", [_GUARD_NOS_TUPLE_r02] = "_GUARD_NOS_TUPLE_r02", [_GUARD_NOS_TUPLE_r12] = "_GUARD_NOS_TUPLE_r12", [_GUARD_NOS_TUPLE_r22] = "_GUARD_NOS_TUPLE_r22", [_GUARD_NOS_TUPLE_r33] = "_GUARD_NOS_TUPLE_r33", + [_GUARD_NOS_TUPLE_r44] = "_GUARD_NOS_TUPLE_r44", + [_GUARD_NOS_TUPLE_r55] = "_GUARD_NOS_TUPLE_r55", [_GUARD_NOS_UNICODE] = "_GUARD_NOS_UNICODE", [_GUARD_NOS_UNICODE_r02] = "_GUARD_NOS_UNICODE_r02", [_GUARD_NOS_UNICODE_r12] = "_GUARD_NOS_UNICODE_r12", [_GUARD_NOS_UNICODE_r22] = "_GUARD_NOS_UNICODE_r22", [_GUARD_NOS_UNICODE_r33] = "_GUARD_NOS_UNICODE_r33", + [_GUARD_NOS_UNICODE_r44] = "_GUARD_NOS_UNICODE_r44", + [_GUARD_NOS_UNICODE_r55] = "_GUARD_NOS_UNICODE_r55", [_GUARD_NOT_EXHAUSTED_LIST] = "_GUARD_NOT_EXHAUSTED_LIST", [_GUARD_NOT_EXHAUSTED_LIST_r02] = "_GUARD_NOT_EXHAUSTED_LIST_r02", [_GUARD_NOT_EXHAUSTED_LIST_r12] = "_GUARD_NOT_EXHAUSTED_LIST_r12", [_GUARD_NOT_EXHAUSTED_LIST_r22] = "_GUARD_NOT_EXHAUSTED_LIST_r22", [_GUARD_NOT_EXHAUSTED_LIST_r33] = "_GUARD_NOT_EXHAUSTED_LIST_r33", + [_GUARD_NOT_EXHAUSTED_LIST_r44] = "_GUARD_NOT_EXHAUSTED_LIST_r44", + [_GUARD_NOT_EXHAUSTED_LIST_r55] = "_GUARD_NOT_EXHAUSTED_LIST_r55", [_GUARD_NOT_EXHAUSTED_RANGE] = "_GUARD_NOT_EXHAUSTED_RANGE", [_GUARD_NOT_EXHAUSTED_RANGE_r02] = "_GUARD_NOT_EXHAUSTED_RANGE_r02", [_GUARD_NOT_EXHAUSTED_RANGE_r12] = "_GUARD_NOT_EXHAUSTED_RANGE_r12", [_GUARD_NOT_EXHAUSTED_RANGE_r22] = "_GUARD_NOT_EXHAUSTED_RANGE_r22", [_GUARD_NOT_EXHAUSTED_RANGE_r33] = "_GUARD_NOT_EXHAUSTED_RANGE_r33", + [_GUARD_NOT_EXHAUSTED_RANGE_r44] = "_GUARD_NOT_EXHAUSTED_RANGE_r44", + [_GUARD_NOT_EXHAUSTED_RANGE_r55] = "_GUARD_NOT_EXHAUSTED_RANGE_r55", [_GUARD_NOT_EXHAUSTED_TUPLE] = "_GUARD_NOT_EXHAUSTED_TUPLE", [_GUARD_NOT_EXHAUSTED_TUPLE_r02] = "_GUARD_NOT_EXHAUSTED_TUPLE_r02", [_GUARD_NOT_EXHAUSTED_TUPLE_r12] = "_GUARD_NOT_EXHAUSTED_TUPLE_r12", [_GUARD_NOT_EXHAUSTED_TUPLE_r22] = "_GUARD_NOT_EXHAUSTED_TUPLE_r22", [_GUARD_NOT_EXHAUSTED_TUPLE_r33] = "_GUARD_NOT_EXHAUSTED_TUPLE_r33", + [_GUARD_NOT_EXHAUSTED_TUPLE_r44] = "_GUARD_NOT_EXHAUSTED_TUPLE_r44", + [_GUARD_NOT_EXHAUSTED_TUPLE_r55] = "_GUARD_NOT_EXHAUSTED_TUPLE_r55", [_GUARD_THIRD_NULL] = "_GUARD_THIRD_NULL", [_GUARD_THIRD_NULL_r03] = "_GUARD_THIRD_NULL_r03", [_GUARD_THIRD_NULL_r13] = "_GUARD_THIRD_NULL_r13", [_GUARD_THIRD_NULL_r23] = "_GUARD_THIRD_NULL_r23", [_GUARD_THIRD_NULL_r33] = "_GUARD_THIRD_NULL_r33", + [_GUARD_THIRD_NULL_r44] = "_GUARD_THIRD_NULL_r44", + [_GUARD_THIRD_NULL_r55] = "_GUARD_THIRD_NULL_r55", [_GUARD_TOS_ANY_DICT] = "_GUARD_TOS_ANY_DICT", [_GUARD_TOS_ANY_DICT_r01] = "_GUARD_TOS_ANY_DICT_r01", [_GUARD_TOS_ANY_DICT_r11] = "_GUARD_TOS_ANY_DICT_r11", [_GUARD_TOS_ANY_DICT_r22] = "_GUARD_TOS_ANY_DICT_r22", [_GUARD_TOS_ANY_DICT_r33] = "_GUARD_TOS_ANY_DICT_r33", + [_GUARD_TOS_ANY_DICT_r44] = "_GUARD_TOS_ANY_DICT_r44", + [_GUARD_TOS_ANY_DICT_r55] = "_GUARD_TOS_ANY_DICT_r55", [_GUARD_TOS_ANY_SET] = "_GUARD_TOS_ANY_SET", [_GUARD_TOS_ANY_SET_r01] = "_GUARD_TOS_ANY_SET_r01", [_GUARD_TOS_ANY_SET_r11] = "_GUARD_TOS_ANY_SET_r11", [_GUARD_TOS_ANY_SET_r22] = "_GUARD_TOS_ANY_SET_r22", [_GUARD_TOS_ANY_SET_r33] = "_GUARD_TOS_ANY_SET_r33", + [_GUARD_TOS_ANY_SET_r44] = "_GUARD_TOS_ANY_SET_r44", + [_GUARD_TOS_ANY_SET_r55] = "_GUARD_TOS_ANY_SET_r55", [_GUARD_TOS_DICT] = "_GUARD_TOS_DICT", [_GUARD_TOS_DICT_r01] = "_GUARD_TOS_DICT_r01", [_GUARD_TOS_DICT_r11] = "_GUARD_TOS_DICT_r11", [_GUARD_TOS_DICT_r22] = "_GUARD_TOS_DICT_r22", [_GUARD_TOS_DICT_r33] = "_GUARD_TOS_DICT_r33", + [_GUARD_TOS_DICT_r44] = "_GUARD_TOS_DICT_r44", + [_GUARD_TOS_DICT_r55] = "_GUARD_TOS_DICT_r55", [_GUARD_TOS_FLOAT] = "_GUARD_TOS_FLOAT", [_GUARD_TOS_FLOAT_r01] = "_GUARD_TOS_FLOAT_r01", [_GUARD_TOS_FLOAT_r11] = "_GUARD_TOS_FLOAT_r11", [_GUARD_TOS_FLOAT_r22] = "_GUARD_TOS_FLOAT_r22", [_GUARD_TOS_FLOAT_r33] = "_GUARD_TOS_FLOAT_r33", + [_GUARD_TOS_FLOAT_r44] = "_GUARD_TOS_FLOAT_r44", + [_GUARD_TOS_FLOAT_r55] = "_GUARD_TOS_FLOAT_r55", [_GUARD_TOS_FROZENDICT] = "_GUARD_TOS_FROZENDICT", [_GUARD_TOS_FROZENDICT_r01] = "_GUARD_TOS_FROZENDICT_r01", [_GUARD_TOS_FROZENDICT_r11] = "_GUARD_TOS_FROZENDICT_r11", [_GUARD_TOS_FROZENDICT_r22] = "_GUARD_TOS_FROZENDICT_r22", [_GUARD_TOS_FROZENDICT_r33] = "_GUARD_TOS_FROZENDICT_r33", + [_GUARD_TOS_FROZENDICT_r44] = "_GUARD_TOS_FROZENDICT_r44", + [_GUARD_TOS_FROZENDICT_r55] = "_GUARD_TOS_FROZENDICT_r55", [_GUARD_TOS_FROZENSET] = "_GUARD_TOS_FROZENSET", [_GUARD_TOS_FROZENSET_r01] = "_GUARD_TOS_FROZENSET_r01", [_GUARD_TOS_FROZENSET_r11] = "_GUARD_TOS_FROZENSET_r11", [_GUARD_TOS_FROZENSET_r22] = "_GUARD_TOS_FROZENSET_r22", [_GUARD_TOS_FROZENSET_r33] = "_GUARD_TOS_FROZENSET_r33", + [_GUARD_TOS_FROZENSET_r44] = "_GUARD_TOS_FROZENSET_r44", + [_GUARD_TOS_FROZENSET_r55] = "_GUARD_TOS_FROZENSET_r55", [_GUARD_TOS_INT] = "_GUARD_TOS_INT", [_GUARD_TOS_INT_r01] = "_GUARD_TOS_INT_r01", [_GUARD_TOS_INT_r11] = "_GUARD_TOS_INT_r11", [_GUARD_TOS_INT_r22] = "_GUARD_TOS_INT_r22", [_GUARD_TOS_INT_r33] = "_GUARD_TOS_INT_r33", + [_GUARD_TOS_INT_r44] = "_GUARD_TOS_INT_r44", + [_GUARD_TOS_INT_r55] = "_GUARD_TOS_INT_r55", [_GUARD_TOS_LIST] = "_GUARD_TOS_LIST", [_GUARD_TOS_LIST_r01] = "_GUARD_TOS_LIST_r01", [_GUARD_TOS_LIST_r11] = "_GUARD_TOS_LIST_r11", [_GUARD_TOS_LIST_r22] = "_GUARD_TOS_LIST_r22", [_GUARD_TOS_LIST_r33] = "_GUARD_TOS_LIST_r33", + [_GUARD_TOS_LIST_r44] = "_GUARD_TOS_LIST_r44", + [_GUARD_TOS_LIST_r55] = "_GUARD_TOS_LIST_r55", [_GUARD_TOS_OVERFLOWED] = "_GUARD_TOS_OVERFLOWED", [_GUARD_TOS_OVERFLOWED_r01] = "_GUARD_TOS_OVERFLOWED_r01", [_GUARD_TOS_OVERFLOWED_r11] = "_GUARD_TOS_OVERFLOWED_r11", [_GUARD_TOS_OVERFLOWED_r22] = "_GUARD_TOS_OVERFLOWED_r22", [_GUARD_TOS_OVERFLOWED_r33] = "_GUARD_TOS_OVERFLOWED_r33", + [_GUARD_TOS_OVERFLOWED_r44] = "_GUARD_TOS_OVERFLOWED_r44", + [_GUARD_TOS_OVERFLOWED_r55] = "_GUARD_TOS_OVERFLOWED_r55", [_GUARD_TOS_SET] = "_GUARD_TOS_SET", [_GUARD_TOS_SET_r01] = "_GUARD_TOS_SET_r01", [_GUARD_TOS_SET_r11] = "_GUARD_TOS_SET_r11", [_GUARD_TOS_SET_r22] = "_GUARD_TOS_SET_r22", [_GUARD_TOS_SET_r33] = "_GUARD_TOS_SET_r33", + [_GUARD_TOS_SET_r44] = "_GUARD_TOS_SET_r44", + [_GUARD_TOS_SET_r55] = "_GUARD_TOS_SET_r55", [_GUARD_TOS_SLICE] = "_GUARD_TOS_SLICE", [_GUARD_TOS_SLICE_r01] = "_GUARD_TOS_SLICE_r01", [_GUARD_TOS_SLICE_r11] = "_GUARD_TOS_SLICE_r11", [_GUARD_TOS_SLICE_r22] = "_GUARD_TOS_SLICE_r22", [_GUARD_TOS_SLICE_r33] = "_GUARD_TOS_SLICE_r33", + [_GUARD_TOS_SLICE_r44] = "_GUARD_TOS_SLICE_r44", + [_GUARD_TOS_SLICE_r55] = "_GUARD_TOS_SLICE_r55", [_GUARD_TOS_TUPLE] = "_GUARD_TOS_TUPLE", [_GUARD_TOS_TUPLE_r01] = "_GUARD_TOS_TUPLE_r01", [_GUARD_TOS_TUPLE_r11] = "_GUARD_TOS_TUPLE_r11", [_GUARD_TOS_TUPLE_r22] = "_GUARD_TOS_TUPLE_r22", [_GUARD_TOS_TUPLE_r33] = "_GUARD_TOS_TUPLE_r33", + [_GUARD_TOS_TUPLE_r44] = "_GUARD_TOS_TUPLE_r44", + [_GUARD_TOS_TUPLE_r55] = "_GUARD_TOS_TUPLE_r55", [_GUARD_TOS_UNICODE] = "_GUARD_TOS_UNICODE", [_GUARD_TOS_UNICODE_r01] = "_GUARD_TOS_UNICODE_r01", [_GUARD_TOS_UNICODE_r11] = "_GUARD_TOS_UNICODE_r11", [_GUARD_TOS_UNICODE_r22] = "_GUARD_TOS_UNICODE_r22", [_GUARD_TOS_UNICODE_r33] = "_GUARD_TOS_UNICODE_r33", + [_GUARD_TOS_UNICODE_r44] = "_GUARD_TOS_UNICODE_r44", + [_GUARD_TOS_UNICODE_r55] = "_GUARD_TOS_UNICODE_r55", [_GUARD_TYPE_VERSION] = "_GUARD_TYPE_VERSION", [_GUARD_TYPE_VERSION_r01] = "_GUARD_TYPE_VERSION_r01", [_GUARD_TYPE_VERSION_r11] = "_GUARD_TYPE_VERSION_r11", [_GUARD_TYPE_VERSION_r22] = "_GUARD_TYPE_VERSION_r22", [_GUARD_TYPE_VERSION_r33] = "_GUARD_TYPE_VERSION_r33", + [_GUARD_TYPE_VERSION_r44] = "_GUARD_TYPE_VERSION_r44", + [_GUARD_TYPE_VERSION_r55] = "_GUARD_TYPE_VERSION_r55", [_GUARD_TYPE_VERSION_AND_LOCK] = "_GUARD_TYPE_VERSION_AND_LOCK", [_GUARD_TYPE_VERSION_AND_LOCK_r01] = "_GUARD_TYPE_VERSION_AND_LOCK_r01", [_GUARD_TYPE_VERSION_AND_LOCK_r11] = "_GUARD_TYPE_VERSION_AND_LOCK_r11", [_GUARD_TYPE_VERSION_AND_LOCK_r22] = "_GUARD_TYPE_VERSION_AND_LOCK_r22", [_GUARD_TYPE_VERSION_AND_LOCK_r33] = "_GUARD_TYPE_VERSION_AND_LOCK_r33", + [_GUARD_TYPE_VERSION_AND_LOCK_r44] = "_GUARD_TYPE_VERSION_AND_LOCK_r44", + [_GUARD_TYPE_VERSION_AND_LOCK_r55] = "_GUARD_TYPE_VERSION_AND_LOCK_r55", [_HANDLE_PENDING_AND_DEOPT] = "_HANDLE_PENDING_AND_DEOPT", [_HANDLE_PENDING_AND_DEOPT_r00] = "_HANDLE_PENDING_AND_DEOPT_r00", [_HANDLE_PENDING_AND_DEOPT_r10] = "_HANDLE_PENDING_AND_DEOPT_r10", [_HANDLE_PENDING_AND_DEOPT_r20] = "_HANDLE_PENDING_AND_DEOPT_r20", [_HANDLE_PENDING_AND_DEOPT_r30] = "_HANDLE_PENDING_AND_DEOPT_r30", + [_HANDLE_PENDING_AND_DEOPT_r40] = "_HANDLE_PENDING_AND_DEOPT_r40", + [_HANDLE_PENDING_AND_DEOPT_r50] = "_HANDLE_PENDING_AND_DEOPT_r50", [_IMPORT_FROM] = "_IMPORT_FROM", [_IMPORT_FROM_r12] = "_IMPORT_FROM_r12", [_IMPORT_NAME] = "_IMPORT_NAME", @@ -4964,14 +5505,20 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_INSERT_1_LOAD_CONST_INLINE_r02] = "_INSERT_1_LOAD_CONST_INLINE_r02", [_INSERT_1_LOAD_CONST_INLINE_r12] = "_INSERT_1_LOAD_CONST_INLINE_r12", [_INSERT_1_LOAD_CONST_INLINE_r23] = "_INSERT_1_LOAD_CONST_INLINE_r23", + [_INSERT_1_LOAD_CONST_INLINE_r34] = "_INSERT_1_LOAD_CONST_INLINE_r34", + [_INSERT_1_LOAD_CONST_INLINE_r45] = "_INSERT_1_LOAD_CONST_INLINE_r45", [_INSERT_1_LOAD_CONST_INLINE_BORROW] = "_INSERT_1_LOAD_CONST_INLINE_BORROW", [_INSERT_1_LOAD_CONST_INLINE_BORROW_r02] = "_INSERT_1_LOAD_CONST_INLINE_BORROW_r02", [_INSERT_1_LOAD_CONST_INLINE_BORROW_r12] = "_INSERT_1_LOAD_CONST_INLINE_BORROW_r12", [_INSERT_1_LOAD_CONST_INLINE_BORROW_r23] = "_INSERT_1_LOAD_CONST_INLINE_BORROW_r23", + [_INSERT_1_LOAD_CONST_INLINE_BORROW_r34] = "_INSERT_1_LOAD_CONST_INLINE_BORROW_r34", + [_INSERT_1_LOAD_CONST_INLINE_BORROW_r45] = "_INSERT_1_LOAD_CONST_INLINE_BORROW_r45", [_INSERT_2_LOAD_CONST_INLINE_BORROW] = "_INSERT_2_LOAD_CONST_INLINE_BORROW", [_INSERT_2_LOAD_CONST_INLINE_BORROW_r03] = "_INSERT_2_LOAD_CONST_INLINE_BORROW_r03", [_INSERT_2_LOAD_CONST_INLINE_BORROW_r13] = "_INSERT_2_LOAD_CONST_INLINE_BORROW_r13", [_INSERT_2_LOAD_CONST_INLINE_BORROW_r23] = "_INSERT_2_LOAD_CONST_INLINE_BORROW_r23", + [_INSERT_2_LOAD_CONST_INLINE_BORROW_r34] = "_INSERT_2_LOAD_CONST_INLINE_BORROW_r34", + [_INSERT_2_LOAD_CONST_INLINE_BORROW_r45] = "_INSERT_2_LOAD_CONST_INLINE_BORROW_r45", [_INSERT_NULL] = "_INSERT_NULL", [_INSERT_NULL_r10] = "_INSERT_NULL_r10", [_IS_NONE] = "_IS_NONE", @@ -4980,31 +5527,43 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_IS_OP_r03] = "_IS_OP_r03", [_IS_OP_r13] = "_IS_OP_r13", [_IS_OP_r23] = "_IS_OP_r23", + [_IS_OP_r34] = "_IS_OP_r34", + [_IS_OP_r45] = "_IS_OP_r45", [_ITER_CHECK_LIST] = "_ITER_CHECK_LIST", [_ITER_CHECK_LIST_r02] = "_ITER_CHECK_LIST_r02", [_ITER_CHECK_LIST_r12] = "_ITER_CHECK_LIST_r12", [_ITER_CHECK_LIST_r22] = "_ITER_CHECK_LIST_r22", [_ITER_CHECK_LIST_r33] = "_ITER_CHECK_LIST_r33", + [_ITER_CHECK_LIST_r44] = "_ITER_CHECK_LIST_r44", + [_ITER_CHECK_LIST_r55] = "_ITER_CHECK_LIST_r55", [_ITER_CHECK_RANGE] = "_ITER_CHECK_RANGE", [_ITER_CHECK_RANGE_r02] = "_ITER_CHECK_RANGE_r02", [_ITER_CHECK_RANGE_r12] = "_ITER_CHECK_RANGE_r12", [_ITER_CHECK_RANGE_r22] = "_ITER_CHECK_RANGE_r22", [_ITER_CHECK_RANGE_r33] = "_ITER_CHECK_RANGE_r33", + [_ITER_CHECK_RANGE_r44] = "_ITER_CHECK_RANGE_r44", + [_ITER_CHECK_RANGE_r55] = "_ITER_CHECK_RANGE_r55", [_ITER_CHECK_TUPLE] = "_ITER_CHECK_TUPLE", [_ITER_CHECK_TUPLE_r02] = "_ITER_CHECK_TUPLE_r02", [_ITER_CHECK_TUPLE_r12] = "_ITER_CHECK_TUPLE_r12", [_ITER_CHECK_TUPLE_r22] = "_ITER_CHECK_TUPLE_r22", [_ITER_CHECK_TUPLE_r33] = "_ITER_CHECK_TUPLE_r33", + [_ITER_CHECK_TUPLE_r44] = "_ITER_CHECK_TUPLE_r44", + [_ITER_CHECK_TUPLE_r55] = "_ITER_CHECK_TUPLE_r55", [_ITER_NEXT_LIST_TIER_TWO] = "_ITER_NEXT_LIST_TIER_TWO", [_ITER_NEXT_LIST_TIER_TWO_r23] = "_ITER_NEXT_LIST_TIER_TWO_r23", [_ITER_NEXT_RANGE] = "_ITER_NEXT_RANGE", [_ITER_NEXT_RANGE_r03] = "_ITER_NEXT_RANGE_r03", [_ITER_NEXT_RANGE_r13] = "_ITER_NEXT_RANGE_r13", [_ITER_NEXT_RANGE_r23] = "_ITER_NEXT_RANGE_r23", + [_ITER_NEXT_RANGE_r34] = "_ITER_NEXT_RANGE_r34", + [_ITER_NEXT_RANGE_r45] = "_ITER_NEXT_RANGE_r45", [_ITER_NEXT_TUPLE] = "_ITER_NEXT_TUPLE", [_ITER_NEXT_TUPLE_r03] = "_ITER_NEXT_TUPLE_r03", [_ITER_NEXT_TUPLE_r13] = "_ITER_NEXT_TUPLE_r13", [_ITER_NEXT_TUPLE_r23] = "_ITER_NEXT_TUPLE_r23", + [_ITER_NEXT_TUPLE_r34] = "_ITER_NEXT_TUPLE_r34", + [_ITER_NEXT_TUPLE_r45] = "_ITER_NEXT_TUPLE_r45", [_JUMP_TO_TOP] = "_JUMP_TO_TOP", [_JUMP_TO_TOP_r00] = "_JUMP_TO_TOP_r00", [_LIST_APPEND] = "_LIST_APPEND", @@ -5019,18 +5578,26 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_LOAD_ATTR_INSTANCE_VALUE_r02] = "_LOAD_ATTR_INSTANCE_VALUE_r02", [_LOAD_ATTR_INSTANCE_VALUE_r12] = "_LOAD_ATTR_INSTANCE_VALUE_r12", [_LOAD_ATTR_INSTANCE_VALUE_r23] = "_LOAD_ATTR_INSTANCE_VALUE_r23", + [_LOAD_ATTR_INSTANCE_VALUE_r34] = "_LOAD_ATTR_INSTANCE_VALUE_r34", + [_LOAD_ATTR_INSTANCE_VALUE_r45] = "_LOAD_ATTR_INSTANCE_VALUE_r45", [_LOAD_ATTR_METHOD_LAZY_DICT] = "_LOAD_ATTR_METHOD_LAZY_DICT", [_LOAD_ATTR_METHOD_LAZY_DICT_r02] = "_LOAD_ATTR_METHOD_LAZY_DICT_r02", [_LOAD_ATTR_METHOD_LAZY_DICT_r12] = "_LOAD_ATTR_METHOD_LAZY_DICT_r12", [_LOAD_ATTR_METHOD_LAZY_DICT_r23] = "_LOAD_ATTR_METHOD_LAZY_DICT_r23", + [_LOAD_ATTR_METHOD_LAZY_DICT_r34] = "_LOAD_ATTR_METHOD_LAZY_DICT_r34", + [_LOAD_ATTR_METHOD_LAZY_DICT_r45] = "_LOAD_ATTR_METHOD_LAZY_DICT_r45", [_LOAD_ATTR_METHOD_NO_DICT] = "_LOAD_ATTR_METHOD_NO_DICT", [_LOAD_ATTR_METHOD_NO_DICT_r02] = "_LOAD_ATTR_METHOD_NO_DICT_r02", [_LOAD_ATTR_METHOD_NO_DICT_r12] = "_LOAD_ATTR_METHOD_NO_DICT_r12", [_LOAD_ATTR_METHOD_NO_DICT_r23] = "_LOAD_ATTR_METHOD_NO_DICT_r23", + [_LOAD_ATTR_METHOD_NO_DICT_r34] = "_LOAD_ATTR_METHOD_NO_DICT_r34", + [_LOAD_ATTR_METHOD_NO_DICT_r45] = "_LOAD_ATTR_METHOD_NO_DICT_r45", [_LOAD_ATTR_METHOD_WITH_VALUES] = "_LOAD_ATTR_METHOD_WITH_VALUES", [_LOAD_ATTR_METHOD_WITH_VALUES_r02] = "_LOAD_ATTR_METHOD_WITH_VALUES_r02", [_LOAD_ATTR_METHOD_WITH_VALUES_r12] = "_LOAD_ATTR_METHOD_WITH_VALUES_r12", [_LOAD_ATTR_METHOD_WITH_VALUES_r23] = "_LOAD_ATTR_METHOD_WITH_VALUES_r23", + [_LOAD_ATTR_METHOD_WITH_VALUES_r34] = "_LOAD_ATTR_METHOD_WITH_VALUES_r34", + [_LOAD_ATTR_METHOD_WITH_VALUES_r45] = "_LOAD_ATTR_METHOD_WITH_VALUES_r45", [_LOAD_ATTR_MODULE] = "_LOAD_ATTR_MODULE", [_LOAD_ATTR_MODULE_r12] = "_LOAD_ATTR_MODULE_r12", [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "_LOAD_ATTR_NONDESCRIPTOR_NO_DICT", @@ -5043,6 +5610,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_LOAD_ATTR_SLOT_r02] = "_LOAD_ATTR_SLOT_r02", [_LOAD_ATTR_SLOT_r12] = "_LOAD_ATTR_SLOT_r12", [_LOAD_ATTR_SLOT_r23] = "_LOAD_ATTR_SLOT_r23", + [_LOAD_ATTR_SLOT_r34] = "_LOAD_ATTR_SLOT_r34", + [_LOAD_ATTR_SLOT_r45] = "_LOAD_ATTR_SLOT_r45", [_LOAD_ATTR_WITH_HINT] = "_LOAD_ATTR_WITH_HINT", [_LOAD_ATTR_WITH_HINT_r12] = "_LOAD_ATTR_WITH_HINT_r12", [_LOAD_BUILD_CLASS] = "_LOAD_BUILD_CLASS", @@ -5051,108 +5620,160 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_LOAD_COMMON_CONSTANT_r01] = "_LOAD_COMMON_CONSTANT_r01", [_LOAD_COMMON_CONSTANT_r12] = "_LOAD_COMMON_CONSTANT_r12", [_LOAD_COMMON_CONSTANT_r23] = "_LOAD_COMMON_CONSTANT_r23", + [_LOAD_COMMON_CONSTANT_r34] = "_LOAD_COMMON_CONSTANT_r34", + [_LOAD_COMMON_CONSTANT_r45] = "_LOAD_COMMON_CONSTANT_r45", [_LOAD_CONST] = "_LOAD_CONST", [_LOAD_CONST_r01] = "_LOAD_CONST_r01", [_LOAD_CONST_r12] = "_LOAD_CONST_r12", [_LOAD_CONST_r23] = "_LOAD_CONST_r23", + [_LOAD_CONST_r34] = "_LOAD_CONST_r34", + [_LOAD_CONST_r45] = "_LOAD_CONST_r45", [_LOAD_CONST_INLINE] = "_LOAD_CONST_INLINE", [_LOAD_CONST_INLINE_r01] = "_LOAD_CONST_INLINE_r01", [_LOAD_CONST_INLINE_r12] = "_LOAD_CONST_INLINE_r12", [_LOAD_CONST_INLINE_r23] = "_LOAD_CONST_INLINE_r23", + [_LOAD_CONST_INLINE_r34] = "_LOAD_CONST_INLINE_r34", + [_LOAD_CONST_INLINE_r45] = "_LOAD_CONST_INLINE_r45", [_LOAD_CONST_INLINE_BORROW] = "_LOAD_CONST_INLINE_BORROW", [_LOAD_CONST_INLINE_BORROW_r01] = "_LOAD_CONST_INLINE_BORROW_r01", [_LOAD_CONST_INLINE_BORROW_r12] = "_LOAD_CONST_INLINE_BORROW_r12", [_LOAD_CONST_INLINE_BORROW_r23] = "_LOAD_CONST_INLINE_BORROW_r23", + [_LOAD_CONST_INLINE_BORROW_r34] = "_LOAD_CONST_INLINE_BORROW_r34", + [_LOAD_CONST_INLINE_BORROW_r45] = "_LOAD_CONST_INLINE_BORROW_r45", [_LOAD_CONST_UNDER_INLINE] = "_LOAD_CONST_UNDER_INLINE", [_LOAD_CONST_UNDER_INLINE_r02] = "_LOAD_CONST_UNDER_INLINE_r02", [_LOAD_CONST_UNDER_INLINE_r12] = "_LOAD_CONST_UNDER_INLINE_r12", [_LOAD_CONST_UNDER_INLINE_r23] = "_LOAD_CONST_UNDER_INLINE_r23", + [_LOAD_CONST_UNDER_INLINE_r34] = "_LOAD_CONST_UNDER_INLINE_r34", + [_LOAD_CONST_UNDER_INLINE_r45] = "_LOAD_CONST_UNDER_INLINE_r45", [_LOAD_CONST_UNDER_INLINE_BORROW] = "_LOAD_CONST_UNDER_INLINE_BORROW", [_LOAD_CONST_UNDER_INLINE_BORROW_r02] = "_LOAD_CONST_UNDER_INLINE_BORROW_r02", [_LOAD_CONST_UNDER_INLINE_BORROW_r12] = "_LOAD_CONST_UNDER_INLINE_BORROW_r12", [_LOAD_CONST_UNDER_INLINE_BORROW_r23] = "_LOAD_CONST_UNDER_INLINE_BORROW_r23", + [_LOAD_CONST_UNDER_INLINE_BORROW_r34] = "_LOAD_CONST_UNDER_INLINE_BORROW_r34", + [_LOAD_CONST_UNDER_INLINE_BORROW_r45] = "_LOAD_CONST_UNDER_INLINE_BORROW_r45", [_LOAD_DEREF] = "_LOAD_DEREF", [_LOAD_DEREF_r01] = "_LOAD_DEREF_r01", [_LOAD_FAST] = "_LOAD_FAST", [_LOAD_FAST_r01] = "_LOAD_FAST_r01", [_LOAD_FAST_r12] = "_LOAD_FAST_r12", [_LOAD_FAST_r23] = "_LOAD_FAST_r23", + [_LOAD_FAST_r34] = "_LOAD_FAST_r34", + [_LOAD_FAST_r45] = "_LOAD_FAST_r45", [_LOAD_FAST_0] = "_LOAD_FAST_0", [_LOAD_FAST_0_r01] = "_LOAD_FAST_0_r01", [_LOAD_FAST_0_r12] = "_LOAD_FAST_0_r12", [_LOAD_FAST_0_r23] = "_LOAD_FAST_0_r23", + [_LOAD_FAST_0_r34] = "_LOAD_FAST_0_r34", + [_LOAD_FAST_0_r45] = "_LOAD_FAST_0_r45", [_LOAD_FAST_1] = "_LOAD_FAST_1", [_LOAD_FAST_1_r01] = "_LOAD_FAST_1_r01", [_LOAD_FAST_1_r12] = "_LOAD_FAST_1_r12", [_LOAD_FAST_1_r23] = "_LOAD_FAST_1_r23", + [_LOAD_FAST_1_r34] = "_LOAD_FAST_1_r34", + [_LOAD_FAST_1_r45] = "_LOAD_FAST_1_r45", [_LOAD_FAST_2] = "_LOAD_FAST_2", [_LOAD_FAST_2_r01] = "_LOAD_FAST_2_r01", [_LOAD_FAST_2_r12] = "_LOAD_FAST_2_r12", [_LOAD_FAST_2_r23] = "_LOAD_FAST_2_r23", + [_LOAD_FAST_2_r34] = "_LOAD_FAST_2_r34", + [_LOAD_FAST_2_r45] = "_LOAD_FAST_2_r45", [_LOAD_FAST_3] = "_LOAD_FAST_3", [_LOAD_FAST_3_r01] = "_LOAD_FAST_3_r01", [_LOAD_FAST_3_r12] = "_LOAD_FAST_3_r12", [_LOAD_FAST_3_r23] = "_LOAD_FAST_3_r23", + [_LOAD_FAST_3_r34] = "_LOAD_FAST_3_r34", + [_LOAD_FAST_3_r45] = "_LOAD_FAST_3_r45", [_LOAD_FAST_4] = "_LOAD_FAST_4", [_LOAD_FAST_4_r01] = "_LOAD_FAST_4_r01", [_LOAD_FAST_4_r12] = "_LOAD_FAST_4_r12", [_LOAD_FAST_4_r23] = "_LOAD_FAST_4_r23", + [_LOAD_FAST_4_r34] = "_LOAD_FAST_4_r34", + [_LOAD_FAST_4_r45] = "_LOAD_FAST_4_r45", [_LOAD_FAST_5] = "_LOAD_FAST_5", [_LOAD_FAST_5_r01] = "_LOAD_FAST_5_r01", [_LOAD_FAST_5_r12] = "_LOAD_FAST_5_r12", [_LOAD_FAST_5_r23] = "_LOAD_FAST_5_r23", + [_LOAD_FAST_5_r34] = "_LOAD_FAST_5_r34", + [_LOAD_FAST_5_r45] = "_LOAD_FAST_5_r45", [_LOAD_FAST_6] = "_LOAD_FAST_6", [_LOAD_FAST_6_r01] = "_LOAD_FAST_6_r01", [_LOAD_FAST_6_r12] = "_LOAD_FAST_6_r12", [_LOAD_FAST_6_r23] = "_LOAD_FAST_6_r23", + [_LOAD_FAST_6_r34] = "_LOAD_FAST_6_r34", + [_LOAD_FAST_6_r45] = "_LOAD_FAST_6_r45", [_LOAD_FAST_7] = "_LOAD_FAST_7", [_LOAD_FAST_7_r01] = "_LOAD_FAST_7_r01", [_LOAD_FAST_7_r12] = "_LOAD_FAST_7_r12", [_LOAD_FAST_7_r23] = "_LOAD_FAST_7_r23", + [_LOAD_FAST_7_r34] = "_LOAD_FAST_7_r34", + [_LOAD_FAST_7_r45] = "_LOAD_FAST_7_r45", [_LOAD_FAST_AND_CLEAR] = "_LOAD_FAST_AND_CLEAR", [_LOAD_FAST_AND_CLEAR_r01] = "_LOAD_FAST_AND_CLEAR_r01", [_LOAD_FAST_AND_CLEAR_r12] = "_LOAD_FAST_AND_CLEAR_r12", [_LOAD_FAST_AND_CLEAR_r23] = "_LOAD_FAST_AND_CLEAR_r23", + [_LOAD_FAST_AND_CLEAR_r34] = "_LOAD_FAST_AND_CLEAR_r34", + [_LOAD_FAST_AND_CLEAR_r45] = "_LOAD_FAST_AND_CLEAR_r45", [_LOAD_FAST_BORROW] = "_LOAD_FAST_BORROW", [_LOAD_FAST_BORROW_r01] = "_LOAD_FAST_BORROW_r01", [_LOAD_FAST_BORROW_r12] = "_LOAD_FAST_BORROW_r12", [_LOAD_FAST_BORROW_r23] = "_LOAD_FAST_BORROW_r23", + [_LOAD_FAST_BORROW_r34] = "_LOAD_FAST_BORROW_r34", + [_LOAD_FAST_BORROW_r45] = "_LOAD_FAST_BORROW_r45", [_LOAD_FAST_BORROW_0] = "_LOAD_FAST_BORROW_0", [_LOAD_FAST_BORROW_0_r01] = "_LOAD_FAST_BORROW_0_r01", [_LOAD_FAST_BORROW_0_r12] = "_LOAD_FAST_BORROW_0_r12", [_LOAD_FAST_BORROW_0_r23] = "_LOAD_FAST_BORROW_0_r23", + [_LOAD_FAST_BORROW_0_r34] = "_LOAD_FAST_BORROW_0_r34", + [_LOAD_FAST_BORROW_0_r45] = "_LOAD_FAST_BORROW_0_r45", [_LOAD_FAST_BORROW_1] = "_LOAD_FAST_BORROW_1", [_LOAD_FAST_BORROW_1_r01] = "_LOAD_FAST_BORROW_1_r01", [_LOAD_FAST_BORROW_1_r12] = "_LOAD_FAST_BORROW_1_r12", [_LOAD_FAST_BORROW_1_r23] = "_LOAD_FAST_BORROW_1_r23", + [_LOAD_FAST_BORROW_1_r34] = "_LOAD_FAST_BORROW_1_r34", + [_LOAD_FAST_BORROW_1_r45] = "_LOAD_FAST_BORROW_1_r45", [_LOAD_FAST_BORROW_2] = "_LOAD_FAST_BORROW_2", [_LOAD_FAST_BORROW_2_r01] = "_LOAD_FAST_BORROW_2_r01", [_LOAD_FAST_BORROW_2_r12] = "_LOAD_FAST_BORROW_2_r12", [_LOAD_FAST_BORROW_2_r23] = "_LOAD_FAST_BORROW_2_r23", + [_LOAD_FAST_BORROW_2_r34] = "_LOAD_FAST_BORROW_2_r34", + [_LOAD_FAST_BORROW_2_r45] = "_LOAD_FAST_BORROW_2_r45", [_LOAD_FAST_BORROW_3] = "_LOAD_FAST_BORROW_3", [_LOAD_FAST_BORROW_3_r01] = "_LOAD_FAST_BORROW_3_r01", [_LOAD_FAST_BORROW_3_r12] = "_LOAD_FAST_BORROW_3_r12", [_LOAD_FAST_BORROW_3_r23] = "_LOAD_FAST_BORROW_3_r23", + [_LOAD_FAST_BORROW_3_r34] = "_LOAD_FAST_BORROW_3_r34", + [_LOAD_FAST_BORROW_3_r45] = "_LOAD_FAST_BORROW_3_r45", [_LOAD_FAST_BORROW_4] = "_LOAD_FAST_BORROW_4", [_LOAD_FAST_BORROW_4_r01] = "_LOAD_FAST_BORROW_4_r01", [_LOAD_FAST_BORROW_4_r12] = "_LOAD_FAST_BORROW_4_r12", [_LOAD_FAST_BORROW_4_r23] = "_LOAD_FAST_BORROW_4_r23", + [_LOAD_FAST_BORROW_4_r34] = "_LOAD_FAST_BORROW_4_r34", + [_LOAD_FAST_BORROW_4_r45] = "_LOAD_FAST_BORROW_4_r45", [_LOAD_FAST_BORROW_5] = "_LOAD_FAST_BORROW_5", [_LOAD_FAST_BORROW_5_r01] = "_LOAD_FAST_BORROW_5_r01", [_LOAD_FAST_BORROW_5_r12] = "_LOAD_FAST_BORROW_5_r12", [_LOAD_FAST_BORROW_5_r23] = "_LOAD_FAST_BORROW_5_r23", + [_LOAD_FAST_BORROW_5_r34] = "_LOAD_FAST_BORROW_5_r34", + [_LOAD_FAST_BORROW_5_r45] = "_LOAD_FAST_BORROW_5_r45", [_LOAD_FAST_BORROW_6] = "_LOAD_FAST_BORROW_6", [_LOAD_FAST_BORROW_6_r01] = "_LOAD_FAST_BORROW_6_r01", [_LOAD_FAST_BORROW_6_r12] = "_LOAD_FAST_BORROW_6_r12", [_LOAD_FAST_BORROW_6_r23] = "_LOAD_FAST_BORROW_6_r23", + [_LOAD_FAST_BORROW_6_r34] = "_LOAD_FAST_BORROW_6_r34", + [_LOAD_FAST_BORROW_6_r45] = "_LOAD_FAST_BORROW_6_r45", [_LOAD_FAST_BORROW_7] = "_LOAD_FAST_BORROW_7", [_LOAD_FAST_BORROW_7_r01] = "_LOAD_FAST_BORROW_7_r01", [_LOAD_FAST_BORROW_7_r12] = "_LOAD_FAST_BORROW_7_r12", [_LOAD_FAST_BORROW_7_r23] = "_LOAD_FAST_BORROW_7_r23", + [_LOAD_FAST_BORROW_7_r34] = "_LOAD_FAST_BORROW_7_r34", + [_LOAD_FAST_BORROW_7_r45] = "_LOAD_FAST_BORROW_7_r45", [_LOAD_FAST_CHECK] = "_LOAD_FAST_CHECK", [_LOAD_FAST_CHECK_r01] = "_LOAD_FAST_CHECK_r01", [_LOAD_FAST_CHECK_r12] = "_LOAD_FAST_CHECK_r12", [_LOAD_FAST_CHECK_r23] = "_LOAD_FAST_CHECK_r23", + [_LOAD_FAST_CHECK_r34] = "_LOAD_FAST_CHECK_r34", + [_LOAD_FAST_CHECK_r45] = "_LOAD_FAST_CHECK_r45", [_LOAD_FROM_DICT_OR_DEREF] = "_LOAD_FROM_DICT_OR_DEREF", [_LOAD_FROM_DICT_OR_DEREF_r11] = "_LOAD_FROM_DICT_OR_DEREF_r11", [_LOAD_GLOBAL] = "_LOAD_GLOBAL", @@ -5165,28 +5786,40 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_LOAD_LOCALS_r01] = "_LOAD_LOCALS_r01", [_LOAD_LOCALS_r12] = "_LOAD_LOCALS_r12", [_LOAD_LOCALS_r23] = "_LOAD_LOCALS_r23", + [_LOAD_LOCALS_r34] = "_LOAD_LOCALS_r34", + [_LOAD_LOCALS_r45] = "_LOAD_LOCALS_r45", [_LOAD_NAME] = "_LOAD_NAME", [_LOAD_NAME_r01] = "_LOAD_NAME_r01", [_LOAD_SMALL_INT] = "_LOAD_SMALL_INT", [_LOAD_SMALL_INT_r01] = "_LOAD_SMALL_INT_r01", [_LOAD_SMALL_INT_r12] = "_LOAD_SMALL_INT_r12", [_LOAD_SMALL_INT_r23] = "_LOAD_SMALL_INT_r23", + [_LOAD_SMALL_INT_r34] = "_LOAD_SMALL_INT_r34", + [_LOAD_SMALL_INT_r45] = "_LOAD_SMALL_INT_r45", [_LOAD_SMALL_INT_0] = "_LOAD_SMALL_INT_0", [_LOAD_SMALL_INT_0_r01] = "_LOAD_SMALL_INT_0_r01", [_LOAD_SMALL_INT_0_r12] = "_LOAD_SMALL_INT_0_r12", [_LOAD_SMALL_INT_0_r23] = "_LOAD_SMALL_INT_0_r23", + [_LOAD_SMALL_INT_0_r34] = "_LOAD_SMALL_INT_0_r34", + [_LOAD_SMALL_INT_0_r45] = "_LOAD_SMALL_INT_0_r45", [_LOAD_SMALL_INT_1] = "_LOAD_SMALL_INT_1", [_LOAD_SMALL_INT_1_r01] = "_LOAD_SMALL_INT_1_r01", [_LOAD_SMALL_INT_1_r12] = "_LOAD_SMALL_INT_1_r12", [_LOAD_SMALL_INT_1_r23] = "_LOAD_SMALL_INT_1_r23", + [_LOAD_SMALL_INT_1_r34] = "_LOAD_SMALL_INT_1_r34", + [_LOAD_SMALL_INT_1_r45] = "_LOAD_SMALL_INT_1_r45", [_LOAD_SMALL_INT_2] = "_LOAD_SMALL_INT_2", [_LOAD_SMALL_INT_2_r01] = "_LOAD_SMALL_INT_2_r01", [_LOAD_SMALL_INT_2_r12] = "_LOAD_SMALL_INT_2_r12", [_LOAD_SMALL_INT_2_r23] = "_LOAD_SMALL_INT_2_r23", + [_LOAD_SMALL_INT_2_r34] = "_LOAD_SMALL_INT_2_r34", + [_LOAD_SMALL_INT_2_r45] = "_LOAD_SMALL_INT_2_r45", [_LOAD_SMALL_INT_3] = "_LOAD_SMALL_INT_3", [_LOAD_SMALL_INT_3_r01] = "_LOAD_SMALL_INT_3_r01", [_LOAD_SMALL_INT_3_r12] = "_LOAD_SMALL_INT_3_r12", [_LOAD_SMALL_INT_3_r23] = "_LOAD_SMALL_INT_3_r23", + [_LOAD_SMALL_INT_3_r34] = "_LOAD_SMALL_INT_3_r34", + [_LOAD_SMALL_INT_3_r45] = "_LOAD_SMALL_INT_3_r45", [_LOAD_SPECIAL] = "_LOAD_SPECIAL", [_LOAD_SPECIAL_r00] = "_LOAD_SPECIAL_r00", [_LOAD_SUPER_ATTR_ATTR] = "_LOAD_SUPER_ATTR_ATTR", @@ -5194,7 +5827,7 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_LOAD_SUPER_ATTR_METHOD] = "_LOAD_SUPER_ATTR_METHOD", [_LOAD_SUPER_ATTR_METHOD_r32] = "_LOAD_SUPER_ATTR_METHOD_r32", [_MAKE_CALLARGS_A_TUPLE] = "_MAKE_CALLARGS_A_TUPLE", - [_MAKE_CALLARGS_A_TUPLE_r33] = "_MAKE_CALLARGS_A_TUPLE_r33", + [_MAKE_CALLARGS_A_TUPLE_r44] = "_MAKE_CALLARGS_A_TUPLE_r44", [_MAKE_CELL] = "_MAKE_CELL", [_MAKE_CELL_r00] = "_MAKE_CELL_r00", [_MAKE_FUNCTION] = "_MAKE_FUNCTION", @@ -5204,6 +5837,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_MAKE_WARM_r11] = "_MAKE_WARM_r11", [_MAKE_WARM_r22] = "_MAKE_WARM_r22", [_MAKE_WARM_r33] = "_MAKE_WARM_r33", + [_MAKE_WARM_r44] = "_MAKE_WARM_r44", + [_MAKE_WARM_r55] = "_MAKE_WARM_r55", [_MAP_ADD] = "_MAP_ADD", [_MAP_ADD_r20] = "_MAP_ADD_r20", [_MATCH_CLASS] = "_MATCH_CLASS", @@ -5214,10 +5849,14 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_MATCH_MAPPING_r02] = "_MATCH_MAPPING_r02", [_MATCH_MAPPING_r12] = "_MATCH_MAPPING_r12", [_MATCH_MAPPING_r23] = "_MATCH_MAPPING_r23", + [_MATCH_MAPPING_r34] = "_MATCH_MAPPING_r34", + [_MATCH_MAPPING_r45] = "_MATCH_MAPPING_r45", [_MATCH_SEQUENCE] = "_MATCH_SEQUENCE", [_MATCH_SEQUENCE_r02] = "_MATCH_SEQUENCE_r02", [_MATCH_SEQUENCE_r12] = "_MATCH_SEQUENCE_r12", [_MATCH_SEQUENCE_r23] = "_MATCH_SEQUENCE_r23", + [_MATCH_SEQUENCE_r34] = "_MATCH_SEQUENCE_r34", + [_MATCH_SEQUENCE_r45] = "_MATCH_SEQUENCE_r45", [_MAYBE_EXPAND_METHOD] = "_MAYBE_EXPAND_METHOD", [_MAYBE_EXPAND_METHOD_r00] = "_MAYBE_EXPAND_METHOD_r00", [_MAYBE_EXPAND_METHOD_KW] = "_MAYBE_EXPAND_METHOD_KW", @@ -5227,6 +5866,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_NOP_r11] = "_NOP_r11", [_NOP_r22] = "_NOP_r22", [_NOP_r33] = "_NOP_r33", + [_NOP_r44] = "_NOP_r44", + [_NOP_r55] = "_NOP_r55", [_POP_CALL] = "_POP_CALL", [_POP_CALL_r20] = "_POP_CALL_r20", [_POP_CALL_LOAD_CONST_INLINE_BORROW] = "_POP_CALL_LOAD_CONST_INLINE_BORROW", @@ -5236,9 +5877,9 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_POP_CALL_ONE_LOAD_CONST_INLINE_BORROW] = "_POP_CALL_ONE_LOAD_CONST_INLINE_BORROW", [_POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31] = "_POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31", [_POP_CALL_TWO] = "_POP_CALL_TWO", - [_POP_CALL_TWO_r30] = "_POP_CALL_TWO_r30", + [_POP_CALL_TWO_r40] = "_POP_CALL_TWO_r40", [_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW] = "_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW", - [_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31] = "_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31", + [_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r41] = "_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r41", [_POP_EXCEPT] = "_POP_EXCEPT", [_POP_EXCEPT_r10] = "_POP_EXCEPT_r10", [_POP_ITER] = "_POP_ITER", @@ -5250,11 +5891,15 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_POP_TOP_FLOAT_r10] = "_POP_TOP_FLOAT_r10", [_POP_TOP_FLOAT_r21] = "_POP_TOP_FLOAT_r21", [_POP_TOP_FLOAT_r32] = "_POP_TOP_FLOAT_r32", + [_POP_TOP_FLOAT_r43] = "_POP_TOP_FLOAT_r43", + [_POP_TOP_FLOAT_r54] = "_POP_TOP_FLOAT_r54", [_POP_TOP_INT] = "_POP_TOP_INT", [_POP_TOP_INT_r00] = "_POP_TOP_INT_r00", [_POP_TOP_INT_r10] = "_POP_TOP_INT_r10", [_POP_TOP_INT_r21] = "_POP_TOP_INT_r21", [_POP_TOP_INT_r32] = "_POP_TOP_INT_r32", + [_POP_TOP_INT_r43] = "_POP_TOP_INT_r43", + [_POP_TOP_INT_r54] = "_POP_TOP_INT_r54", [_POP_TOP_LOAD_CONST_INLINE] = "_POP_TOP_LOAD_CONST_INLINE", [_POP_TOP_LOAD_CONST_INLINE_r11] = "_POP_TOP_LOAD_CONST_INLINE_r11", [_POP_TOP_LOAD_CONST_INLINE_BORROW] = "_POP_TOP_LOAD_CONST_INLINE_BORROW", @@ -5264,11 +5909,15 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_POP_TOP_NOP_r10] = "_POP_TOP_NOP_r10", [_POP_TOP_NOP_r21] = "_POP_TOP_NOP_r21", [_POP_TOP_NOP_r32] = "_POP_TOP_NOP_r32", + [_POP_TOP_NOP_r43] = "_POP_TOP_NOP_r43", + [_POP_TOP_NOP_r54] = "_POP_TOP_NOP_r54", [_POP_TOP_UNICODE] = "_POP_TOP_UNICODE", [_POP_TOP_UNICODE_r00] = "_POP_TOP_UNICODE_r00", [_POP_TOP_UNICODE_r10] = "_POP_TOP_UNICODE_r10", [_POP_TOP_UNICODE_r21] = "_POP_TOP_UNICODE_r21", [_POP_TOP_UNICODE_r32] = "_POP_TOP_UNICODE_r32", + [_POP_TOP_UNICODE_r43] = "_POP_TOP_UNICODE_r43", + [_POP_TOP_UNICODE_r54] = "_POP_TOP_UNICODE_r54", [_POP_TWO] = "_POP_TWO", [_POP_TWO_r20] = "_POP_TWO_r20", [_POP_TWO_LOAD_CONST_INLINE_BORROW] = "_POP_TWO_LOAD_CONST_INLINE_BORROW", @@ -5277,16 +5926,20 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_PUSH_EXC_INFO_r02] = "_PUSH_EXC_INFO_r02", [_PUSH_EXC_INFO_r12] = "_PUSH_EXC_INFO_r12", [_PUSH_EXC_INFO_r23] = "_PUSH_EXC_INFO_r23", + [_PUSH_EXC_INFO_r34] = "_PUSH_EXC_INFO_r34", + [_PUSH_EXC_INFO_r45] = "_PUSH_EXC_INFO_r45", [_PUSH_FRAME] = "_PUSH_FRAME", [_PUSH_FRAME_r10] = "_PUSH_FRAME_r10", [_PUSH_NULL] = "_PUSH_NULL", [_PUSH_NULL_r01] = "_PUSH_NULL_r01", [_PUSH_NULL_r12] = "_PUSH_NULL_r12", [_PUSH_NULL_r23] = "_PUSH_NULL_r23", + [_PUSH_NULL_r34] = "_PUSH_NULL_r34", + [_PUSH_NULL_r45] = "_PUSH_NULL_r45", [_PUSH_NULL_CONDITIONAL] = "_PUSH_NULL_CONDITIONAL", [_PUSH_NULL_CONDITIONAL_r00] = "_PUSH_NULL_CONDITIONAL_r00", [_PY_FRAME_EX] = "_PY_FRAME_EX", - [_PY_FRAME_EX_r31] = "_PY_FRAME_EX_r31", + [_PY_FRAME_EX_r41] = "_PY_FRAME_EX_r41", [_PY_FRAME_GENERAL] = "_PY_FRAME_GENERAL", [_PY_FRAME_GENERAL_r01] = "_PY_FRAME_GENERAL_r01", [_PY_FRAME_KW] = "_PY_FRAME_KW", @@ -5303,11 +5956,15 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_REPLACE_WITH_TRUE_r02] = "_REPLACE_WITH_TRUE_r02", [_REPLACE_WITH_TRUE_r12] = "_REPLACE_WITH_TRUE_r12", [_REPLACE_WITH_TRUE_r23] = "_REPLACE_WITH_TRUE_r23", + [_REPLACE_WITH_TRUE_r34] = "_REPLACE_WITH_TRUE_r34", + [_REPLACE_WITH_TRUE_r45] = "_REPLACE_WITH_TRUE_r45", [_RESUME_CHECK] = "_RESUME_CHECK", [_RESUME_CHECK_r00] = "_RESUME_CHECK_r00", [_RESUME_CHECK_r11] = "_RESUME_CHECK_r11", [_RESUME_CHECK_r22] = "_RESUME_CHECK_r22", [_RESUME_CHECK_r33] = "_RESUME_CHECK_r33", + [_RESUME_CHECK_r44] = "_RESUME_CHECK_r44", + [_RESUME_CHECK_r55] = "_RESUME_CHECK_r55", [_RETURN_GENERATOR] = "_RETURN_GENERATOR", [_RETURN_GENERATOR_r01] = "_RETURN_GENERATOR_r01", [_RETURN_VALUE] = "_RETURN_VALUE", @@ -5317,6 +5974,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_SAVE_RETURN_OFFSET_r11] = "_SAVE_RETURN_OFFSET_r11", [_SAVE_RETURN_OFFSET_r22] = "_SAVE_RETURN_OFFSET_r22", [_SAVE_RETURN_OFFSET_r33] = "_SAVE_RETURN_OFFSET_r33", + [_SAVE_RETURN_OFFSET_r44] = "_SAVE_RETURN_OFFSET_r44", + [_SAVE_RETURN_OFFSET_r55] = "_SAVE_RETURN_OFFSET_r55", [_SEND_GEN_FRAME] = "_SEND_GEN_FRAME", [_SEND_GEN_FRAME_r22] = "_SEND_GEN_FRAME_r22", [_SETUP_ANNOTATIONS] = "_SETUP_ANNOTATIONS", @@ -5328,11 +5987,15 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_SET_FUNCTION_ATTRIBUTE_r11] = "_SET_FUNCTION_ATTRIBUTE_r11", [_SET_FUNCTION_ATTRIBUTE_r21] = "_SET_FUNCTION_ATTRIBUTE_r21", [_SET_FUNCTION_ATTRIBUTE_r32] = "_SET_FUNCTION_ATTRIBUTE_r32", + [_SET_FUNCTION_ATTRIBUTE_r43] = "_SET_FUNCTION_ATTRIBUTE_r43", + [_SET_FUNCTION_ATTRIBUTE_r54] = "_SET_FUNCTION_ATTRIBUTE_r54", [_SET_IP] = "_SET_IP", [_SET_IP_r00] = "_SET_IP_r00", [_SET_IP_r11] = "_SET_IP_r11", [_SET_IP_r22] = "_SET_IP_r22", [_SET_IP_r33] = "_SET_IP_r33", + [_SET_IP_r44] = "_SET_IP_r44", + [_SET_IP_r55] = "_SET_IP_r55", [_SET_UPDATE] = "_SET_UPDATE", [_SET_UPDATE_r10] = "_SET_UPDATE_r10", [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW] = "_SHUFFLE_2_LOAD_CONST_INLINE_BORROW", @@ -5340,24 +6003,46 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12] = "_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12", [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22] = "_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22", [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32] = "_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32", + [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r43] = "_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r43", + [_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r54] = "_SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r54", [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW", [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03", [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13", [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23", [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33", + [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r44] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r44", + [_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r55] = "_SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r55", [_SPILL_OR_RELOAD] = "_SPILL_OR_RELOAD", [_SPILL_OR_RELOAD_r01] = "_SPILL_OR_RELOAD_r01", [_SPILL_OR_RELOAD_r02] = "_SPILL_OR_RELOAD_r02", [_SPILL_OR_RELOAD_r03] = "_SPILL_OR_RELOAD_r03", + [_SPILL_OR_RELOAD_r04] = "_SPILL_OR_RELOAD_r04", + [_SPILL_OR_RELOAD_r05] = "_SPILL_OR_RELOAD_r05", [_SPILL_OR_RELOAD_r10] = "_SPILL_OR_RELOAD_r10", [_SPILL_OR_RELOAD_r12] = "_SPILL_OR_RELOAD_r12", [_SPILL_OR_RELOAD_r13] = "_SPILL_OR_RELOAD_r13", + [_SPILL_OR_RELOAD_r14] = "_SPILL_OR_RELOAD_r14", + [_SPILL_OR_RELOAD_r15] = "_SPILL_OR_RELOAD_r15", [_SPILL_OR_RELOAD_r20] = "_SPILL_OR_RELOAD_r20", [_SPILL_OR_RELOAD_r21] = "_SPILL_OR_RELOAD_r21", [_SPILL_OR_RELOAD_r23] = "_SPILL_OR_RELOAD_r23", + [_SPILL_OR_RELOAD_r24] = "_SPILL_OR_RELOAD_r24", + [_SPILL_OR_RELOAD_r25] = "_SPILL_OR_RELOAD_r25", [_SPILL_OR_RELOAD_r30] = "_SPILL_OR_RELOAD_r30", [_SPILL_OR_RELOAD_r31] = "_SPILL_OR_RELOAD_r31", [_SPILL_OR_RELOAD_r32] = "_SPILL_OR_RELOAD_r32", + [_SPILL_OR_RELOAD_r34] = "_SPILL_OR_RELOAD_r34", + [_SPILL_OR_RELOAD_r35] = "_SPILL_OR_RELOAD_r35", + [_SPILL_OR_RELOAD_r40] = "_SPILL_OR_RELOAD_r40", + [_SPILL_OR_RELOAD_r41] = "_SPILL_OR_RELOAD_r41", + [_SPILL_OR_RELOAD_r42] = "_SPILL_OR_RELOAD_r42", + [_SPILL_OR_RELOAD_r43] = "_SPILL_OR_RELOAD_r43", + [_SPILL_OR_RELOAD_r45] = "_SPILL_OR_RELOAD_r45", + [_SPILL_OR_RELOAD_r50] = "_SPILL_OR_RELOAD_r50", + [_SPILL_OR_RELOAD_r51] = "_SPILL_OR_RELOAD_r51", + [_SPILL_OR_RELOAD_r52] = "_SPILL_OR_RELOAD_r52", + [_SPILL_OR_RELOAD_r53] = "_SPILL_OR_RELOAD_r53", + [_SPILL_OR_RELOAD_r54] = "_SPILL_OR_RELOAD_r54", [_START_EXECUTOR] = "_START_EXECUTOR", [_START_EXECUTOR_r00] = "_START_EXECUTOR_r00", [_STORE_ATTR] = "_STORE_ATTR", @@ -5375,7 +6060,7 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_STORE_NAME] = "_STORE_NAME", [_STORE_NAME_r10] = "_STORE_NAME_r10", [_STORE_SLICE] = "_STORE_SLICE", - [_STORE_SLICE_r30] = "_STORE_SLICE_r30", + [_STORE_SLICE_r40] = "_STORE_SLICE_r40", [_STORE_SUBSCR] = "_STORE_SUBSCR", [_STORE_SUBSCR_r30] = "_STORE_SUBSCR_r30", [_STORE_SUBSCR_DICT] = "_STORE_SUBSCR_DICT", @@ -5389,61 +6074,85 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_SWAP_2_r12] = "_SWAP_2_r12", [_SWAP_2_r22] = "_SWAP_2_r22", [_SWAP_2_r33] = "_SWAP_2_r33", + [_SWAP_2_r44] = "_SWAP_2_r44", + [_SWAP_2_r55] = "_SWAP_2_r55", [_SWAP_3] = "_SWAP_3", [_SWAP_3_r03] = "_SWAP_3_r03", [_SWAP_3_r13] = "_SWAP_3_r13", [_SWAP_3_r23] = "_SWAP_3_r23", [_SWAP_3_r33] = "_SWAP_3_r33", + [_SWAP_3_r44] = "_SWAP_3_r44", + [_SWAP_3_r55] = "_SWAP_3_r55", [_SWAP_FAST] = "_SWAP_FAST", [_SWAP_FAST_r01] = "_SWAP_FAST_r01", [_SWAP_FAST_r11] = "_SWAP_FAST_r11", [_SWAP_FAST_r22] = "_SWAP_FAST_r22", [_SWAP_FAST_r33] = "_SWAP_FAST_r33", + [_SWAP_FAST_r44] = "_SWAP_FAST_r44", + [_SWAP_FAST_r55] = "_SWAP_FAST_r55", [_SWAP_FAST_0] = "_SWAP_FAST_0", [_SWAP_FAST_0_r01] = "_SWAP_FAST_0_r01", [_SWAP_FAST_0_r11] = "_SWAP_FAST_0_r11", [_SWAP_FAST_0_r22] = "_SWAP_FAST_0_r22", [_SWAP_FAST_0_r33] = "_SWAP_FAST_0_r33", + [_SWAP_FAST_0_r44] = "_SWAP_FAST_0_r44", + [_SWAP_FAST_0_r55] = "_SWAP_FAST_0_r55", [_SWAP_FAST_1] = "_SWAP_FAST_1", [_SWAP_FAST_1_r01] = "_SWAP_FAST_1_r01", [_SWAP_FAST_1_r11] = "_SWAP_FAST_1_r11", [_SWAP_FAST_1_r22] = "_SWAP_FAST_1_r22", [_SWAP_FAST_1_r33] = "_SWAP_FAST_1_r33", + [_SWAP_FAST_1_r44] = "_SWAP_FAST_1_r44", + [_SWAP_FAST_1_r55] = "_SWAP_FAST_1_r55", [_SWAP_FAST_2] = "_SWAP_FAST_2", [_SWAP_FAST_2_r01] = "_SWAP_FAST_2_r01", [_SWAP_FAST_2_r11] = "_SWAP_FAST_2_r11", [_SWAP_FAST_2_r22] = "_SWAP_FAST_2_r22", [_SWAP_FAST_2_r33] = "_SWAP_FAST_2_r33", + [_SWAP_FAST_2_r44] = "_SWAP_FAST_2_r44", + [_SWAP_FAST_2_r55] = "_SWAP_FAST_2_r55", [_SWAP_FAST_3] = "_SWAP_FAST_3", [_SWAP_FAST_3_r01] = "_SWAP_FAST_3_r01", [_SWAP_FAST_3_r11] = "_SWAP_FAST_3_r11", [_SWAP_FAST_3_r22] = "_SWAP_FAST_3_r22", [_SWAP_FAST_3_r33] = "_SWAP_FAST_3_r33", + [_SWAP_FAST_3_r44] = "_SWAP_FAST_3_r44", + [_SWAP_FAST_3_r55] = "_SWAP_FAST_3_r55", [_SWAP_FAST_4] = "_SWAP_FAST_4", [_SWAP_FAST_4_r01] = "_SWAP_FAST_4_r01", [_SWAP_FAST_4_r11] = "_SWAP_FAST_4_r11", [_SWAP_FAST_4_r22] = "_SWAP_FAST_4_r22", [_SWAP_FAST_4_r33] = "_SWAP_FAST_4_r33", + [_SWAP_FAST_4_r44] = "_SWAP_FAST_4_r44", + [_SWAP_FAST_4_r55] = "_SWAP_FAST_4_r55", [_SWAP_FAST_5] = "_SWAP_FAST_5", [_SWAP_FAST_5_r01] = "_SWAP_FAST_5_r01", [_SWAP_FAST_5_r11] = "_SWAP_FAST_5_r11", [_SWAP_FAST_5_r22] = "_SWAP_FAST_5_r22", [_SWAP_FAST_5_r33] = "_SWAP_FAST_5_r33", + [_SWAP_FAST_5_r44] = "_SWAP_FAST_5_r44", + [_SWAP_FAST_5_r55] = "_SWAP_FAST_5_r55", [_SWAP_FAST_6] = "_SWAP_FAST_6", [_SWAP_FAST_6_r01] = "_SWAP_FAST_6_r01", [_SWAP_FAST_6_r11] = "_SWAP_FAST_6_r11", [_SWAP_FAST_6_r22] = "_SWAP_FAST_6_r22", [_SWAP_FAST_6_r33] = "_SWAP_FAST_6_r33", + [_SWAP_FAST_6_r44] = "_SWAP_FAST_6_r44", + [_SWAP_FAST_6_r55] = "_SWAP_FAST_6_r55", [_SWAP_FAST_7] = "_SWAP_FAST_7", [_SWAP_FAST_7_r01] = "_SWAP_FAST_7_r01", [_SWAP_FAST_7_r11] = "_SWAP_FAST_7_r11", [_SWAP_FAST_7_r22] = "_SWAP_FAST_7_r22", [_SWAP_FAST_7_r33] = "_SWAP_FAST_7_r33", + [_SWAP_FAST_7_r44] = "_SWAP_FAST_7_r44", + [_SWAP_FAST_7_r55] = "_SWAP_FAST_7_r55", [_TIER2_RESUME_CHECK] = "_TIER2_RESUME_CHECK", [_TIER2_RESUME_CHECK_r00] = "_TIER2_RESUME_CHECK_r00", [_TIER2_RESUME_CHECK_r11] = "_TIER2_RESUME_CHECK_r11", [_TIER2_RESUME_CHECK_r22] = "_TIER2_RESUME_CHECK_r22", [_TIER2_RESUME_CHECK_r33] = "_TIER2_RESUME_CHECK_r33", + [_TIER2_RESUME_CHECK_r44] = "_TIER2_RESUME_CHECK_r44", + [_TIER2_RESUME_CHECK_r55] = "_TIER2_RESUME_CHECK_r55", [_TO_BOOL] = "_TO_BOOL", [_TO_BOOL_r11] = "_TO_BOOL_r11", [_TO_BOOL_BOOL] = "_TO_BOOL_BOOL", @@ -5451,23 +6160,33 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_TO_BOOL_BOOL_r11] = "_TO_BOOL_BOOL_r11", [_TO_BOOL_BOOL_r22] = "_TO_BOOL_BOOL_r22", [_TO_BOOL_BOOL_r33] = "_TO_BOOL_BOOL_r33", + [_TO_BOOL_BOOL_r44] = "_TO_BOOL_BOOL_r44", + [_TO_BOOL_BOOL_r55] = "_TO_BOOL_BOOL_r55", [_TO_BOOL_INT] = "_TO_BOOL_INT", [_TO_BOOL_INT_r02] = "_TO_BOOL_INT_r02", [_TO_BOOL_INT_r12] = "_TO_BOOL_INT_r12", [_TO_BOOL_INT_r23] = "_TO_BOOL_INT_r23", + [_TO_BOOL_INT_r34] = "_TO_BOOL_INT_r34", + [_TO_BOOL_INT_r45] = "_TO_BOOL_INT_r45", [_TO_BOOL_LIST] = "_TO_BOOL_LIST", [_TO_BOOL_LIST_r02] = "_TO_BOOL_LIST_r02", [_TO_BOOL_LIST_r12] = "_TO_BOOL_LIST_r12", [_TO_BOOL_LIST_r23] = "_TO_BOOL_LIST_r23", + [_TO_BOOL_LIST_r34] = "_TO_BOOL_LIST_r34", + [_TO_BOOL_LIST_r45] = "_TO_BOOL_LIST_r45", [_TO_BOOL_NONE] = "_TO_BOOL_NONE", [_TO_BOOL_NONE_r01] = "_TO_BOOL_NONE_r01", [_TO_BOOL_NONE_r11] = "_TO_BOOL_NONE_r11", [_TO_BOOL_NONE_r22] = "_TO_BOOL_NONE_r22", [_TO_BOOL_NONE_r33] = "_TO_BOOL_NONE_r33", + [_TO_BOOL_NONE_r44] = "_TO_BOOL_NONE_r44", + [_TO_BOOL_NONE_r55] = "_TO_BOOL_NONE_r55", [_TO_BOOL_STR] = "_TO_BOOL_STR", [_TO_BOOL_STR_r02] = "_TO_BOOL_STR_r02", [_TO_BOOL_STR_r12] = "_TO_BOOL_STR_r12", [_TO_BOOL_STR_r23] = "_TO_BOOL_STR_r23", + [_TO_BOOL_STR_r34] = "_TO_BOOL_STR_r34", + [_TO_BOOL_STR_r45] = "_TO_BOOL_STR_r45", [_UNARY_INVERT] = "_UNARY_INVERT", [_UNARY_INVERT_r12] = "_UNARY_INVERT_r12", [_UNARY_NEGATIVE] = "_UNARY_NEGATIVE", @@ -5477,6 +6196,8 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_UNARY_NOT_r11] = "_UNARY_NOT_r11", [_UNARY_NOT_r22] = "_UNARY_NOT_r22", [_UNARY_NOT_r33] = "_UNARY_NOT_r33", + [_UNARY_NOT_r44] = "_UNARY_NOT_r44", + [_UNARY_NOT_r55] = "_UNARY_NOT_r55", [_UNPACK_EX] = "_UNPACK_EX", [_UNPACK_EX_r10] = "_UNPACK_EX_r10", [_UNPACK_SEQUENCE] = "_UNPACK_SEQUENCE", @@ -5488,7 +6209,7 @@ const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = { [_UNPACK_SEQUENCE_TWO_TUPLE] = "_UNPACK_SEQUENCE_TWO_TUPLE", [_UNPACK_SEQUENCE_TWO_TUPLE_r12] = "_UNPACK_SEQUENCE_TWO_TUPLE_r12", [_WITH_EXCEPT_START] = "_WITH_EXCEPT_START", - [_WITH_EXCEPT_START_r33] = "_WITH_EXCEPT_START_r33", + [_WITH_EXCEPT_START_r55] = "_WITH_EXCEPT_START_r55", [_YIELD_VALUE] = "_YIELD_VALUE", [_YIELD_VALUE_r11] = "_YIELD_VALUE_r11", }; diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 09004545267026..2fec97697b9ac0 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -17,6 +17,7 @@ } case _NOP_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -24,9 +25,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _NOP_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -36,9 +41,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _NOP_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -50,6 +59,51 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _NOP_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _NOP_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } case _CHECK_PERIODIC_r00: { @@ -62,9 +116,21 @@ SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } + #if MAX_CACHED_REGISTER >= 1 _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; @@ -85,9 +151,21 @@ JUMP_TO_ERROR(); } } + #if MAX_CACHED_REGISTER >= 1 _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; @@ -130,6 +208,7 @@ } case _RESUME_CHECK_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -164,9 +243,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _RESUME_CHECK_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -206,9 +289,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _RESUME_CHECK_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -253,11 +340,132 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _RESUME_CHECK_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + #if defined(__EMSCRIPTEN__) + if (_Py_emscripten_signal_clock == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _Py_emscripten_signal_clock -= Py_EMSCRIPTEN_SIGNAL_HANDLING; + #endif + uintptr_t eval_breaker = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker); + uintptr_t version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); + assert((version & _PY_EVAL_EVENTS_MASK) == 0); + if (eval_breaker != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + if (frame->tlbc_index != + ((_PyThreadStateImpl *)tstate)->tlbc_index) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _RESUME_CHECK_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + #if defined(__EMSCRIPTEN__) + if (_Py_emscripten_signal_clock == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _Py_emscripten_signal_clock -= Py_EMSCRIPTEN_SIGNAL_HANDLING; + #endif + uintptr_t eval_breaker = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker); + uintptr_t version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); + assert((version & _PY_EVAL_EVENTS_MASK) == 0); + if (eval_breaker != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + if (frame->tlbc_index != + ((_PyThreadStateImpl *)tstate)->tlbc_index) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } /* _MONITOR_RESUME is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ case _LOAD_FAST_CHECK_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -278,9 +486,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_CHECK_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -306,9 +518,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_CHECK_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -337,9 +553,92 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_CHECK_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + _PyStackRef value_s = GETLOCAL(oparg); + if (PyStackRef_IsNull(value_s)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, + UNBOUNDLOCAL_ERROR_MSG, + PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) + ); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + value = PyStackRef_DUP(value_s); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_CHECK_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + _PyStackRef value_s = GETLOCAL(oparg); + if (PyStackRef_IsNull(value_s)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, + UNBOUNDLOCAL_ERROR_MSG, + PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) + ); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + value = PyStackRef_DUP(value_s); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_0_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -351,9 +650,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_0_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -367,9 +670,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_0_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -385,9 +692,63 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_0_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 0; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_0_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 0; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_1_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -399,9 +760,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_1_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -415,9 +780,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_1_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -433,10 +802,64 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_2_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _LOAD_FAST_1_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_1_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_2_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; oparg = 2; @@ -447,9 +870,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_2_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -463,9 +890,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_2_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -481,9 +912,63 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_2_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_2_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_3_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -495,9 +980,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_3_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -511,9 +1000,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _LOAD_FAST_3_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -529,61 +1022,67 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_4_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_FAST_4_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_3_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 4; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 3; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache1 = value; + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_4_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_3_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 4; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 3; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache2 = value; + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_5_r01: { + case _LOAD_FAST_4_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = 5; + oparg = 4; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); @@ -591,14 +1090,18 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_5_r12: { + case _LOAD_FAST_4_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 5; + oparg = 4; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); @@ -607,15 +1110,19 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_5_r23: { + case _LOAD_FAST_4_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 5; + oparg = 4; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); @@ -625,61 +1132,67 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_6_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_FAST_6_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_4_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 6; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 4; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache1 = value; + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_6_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_4_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 6; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 4; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache2 = value; + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_7_r01: { + case _LOAD_FAST_5_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = 7; + oparg = 5; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); @@ -687,14 +1200,18 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_7_r12: { + case _LOAD_FAST_5_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 7; + oparg = 5; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); @@ -703,15 +1220,19 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_7_r23: { + case _LOAD_FAST_5_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 7; + oparg = 5; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); @@ -721,346 +1242,392 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = CURRENT_OPARG(); - assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_FAST_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_5_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 5; + assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache1 = value; + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_5_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 5; + assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_DUP(GETLOCAL(oparg)); - _tos_cache2 = value; + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_0_r01: { + case _LOAD_FAST_6_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = 0; + oparg = 6; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_0_r12: { + case _LOAD_FAST_6_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 0; + oparg = 6; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_0_r23: { + case _LOAD_FAST_6_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 0; + oparg = 6; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_1_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = 1; - assert(oparg == CURRENT_OPARG()); - assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_FAST_BORROW_1_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_6_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 1; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 6; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache1 = value; + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_1_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_6_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 6; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache2 = value; + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_2_r01: { + case _LOAD_FAST_7_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = 2; + oparg = 7; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_2_r12: { + case _LOAD_FAST_7_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 2; + oparg = 7; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_2_r23: { + case _LOAD_FAST_7_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 2; + oparg = 7; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_3_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = 3; - assert(oparg == CURRENT_OPARG()); - assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_FAST_BORROW_3_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_7_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 3; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 7; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache1 = value; + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_3_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_7_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 3; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 7; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache2 = value; + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_4_r01: { + case _LOAD_FAST_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = 4; - assert(oparg == CURRENT_OPARG()); + oparg = CURRENT_OPARG(); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_4_r12: { + case _LOAD_FAST_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 4; - assert(oparg == CURRENT_OPARG()); + oparg = CURRENT_OPARG(); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_4_r23: { + case _LOAD_FAST_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 4; - assert(oparg == CURRENT_OPARG()); + oparg = CURRENT_OPARG(); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg)); _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_5_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_FAST_BORROW_5_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 5; - assert(oparg == CURRENT_OPARG()); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache1 = value; + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_5_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 5; - assert(oparg == CURRENT_OPARG()); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache2 = value; + value = PyStackRef_DUP(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_6_r01: { + case _LOAD_FAST_BORROW_0_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = 6; + oparg = 0; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_Borrow(GETLOCAL(oparg)); @@ -1068,14 +1635,18 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_6_r12: { + case _LOAD_FAST_BORROW_0_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 6; + oparg = 0; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_Borrow(GETLOCAL(oparg)); @@ -1084,15 +1655,19 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_6_r23: { + case _LOAD_FAST_BORROW_0_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 6; + oparg = 0; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_Borrow(GETLOCAL(oparg)); @@ -1102,75 +1677,87 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_7_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_FAST_BORROW_7_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_BORROW_0_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 7; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 0; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache1 = value; + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_7_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_BORROW_0_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 7; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 0; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_Borrow(GETLOCAL(oparg)); - _tos_cache2 = value; + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_r01: { + case _LOAD_FAST_BORROW_1_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = CURRENT_OPARG(); + oparg = 1; + assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_r12: { + case _LOAD_FAST_BORROW_1_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); + oparg = 1; + assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache1 = value; @@ -1178,15 +1765,20 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_BORROW_r23: { + case _LOAD_FAST_BORROW_1_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); + oparg = 1; + assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache2 = value; @@ -1195,2717 +1787,3181 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_AND_CLEAR_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = CURRENT_OPARG(); - value = GETLOCAL(oparg); - GETLOCAL(oparg) = PyStackRef_NULL; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_FAST_AND_CLEAR_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_BORROW_1_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - value = GETLOCAL(oparg); - GETLOCAL(oparg) = PyStackRef_NULL; - _tos_cache1 = value; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FAST_AND_CLEAR_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_BORROW_1_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - value = GETLOCAL(oparg); - GETLOCAL(oparg) = PyStackRef_NULL; - _tos_cache2 = value; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_r01: { + case _LOAD_FAST_BORROW_2_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = CURRENT_OPARG(); - PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg); - value = PyStackRef_FromPyObjectBorrow(obj); + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_r12: { + case _LOAD_FAST_BORROW_2_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg); - value = PyStackRef_FromPyObjectBorrow(obj); + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_r23: { + case _LOAD_FAST_BORROW_2_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg); - value = PyStackRef_FromPyObjectBorrow(obj); + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_0_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = 0; - assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_SMALL_INT_0_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_BORROW_2_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 2; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache1 = value; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_0_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_BORROW_2_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 0; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 2; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache2 = value; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_1_r01: { + case _LOAD_FAST_BORROW_3_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = 1; + oparg = 3; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_1_r12: { + case _LOAD_FAST_BORROW_3_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 1; + oparg = 3; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_1_r23: { + case _LOAD_FAST_BORROW_3_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 1; + oparg = 3; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_2_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = 2; - assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_SMALL_INT_2_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_BORROW_3_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 2; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 3; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache1 = value; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_2_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_BORROW_3_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 2; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 3; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache2 = value; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_3_r01: { + case _LOAD_FAST_BORROW_4_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = 3; + oparg = 4; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_3_r12: { + case _LOAD_FAST_BORROW_4_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 3; + oparg = 4; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_3_r23: { + case _LOAD_FAST_BORROW_4_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 3; + oparg = 4; assert(oparg == CURRENT_OPARG()); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = CURRENT_OPARG(); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_SMALL_INT_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_BORROW_4_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache1 = value; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SMALL_INT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_BORROW_4_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - assert(oparg < _PY_NSMALLPOSINTS); - PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; - value = PyStackRef_FromPyObjectBorrow(obj); - _tos_cache2 = value; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_0_r01: { + case _LOAD_FAST_BORROW_5_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - oparg = 0; + oparg = 5; assert(oparg == CURRENT_OPARG()); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_0_r11: { + case _LOAD_FAST_BORROW_5_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 0; + oparg = 5; assert(oparg == CURRENT_OPARG()); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_0_r22: { + case _LOAD_FAST_BORROW_5_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 0; + oparg = 5; assert(oparg == CURRENT_OPARG()); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_0_r33: { + case _LOAD_FAST_BORROW_5_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 0; + oparg = 5; assert(oparg == CURRENT_OPARG()); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_1_r01: { + case _LOAD_FAST_BORROW_5_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_BORROW_6_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - oparg = 1; + oparg = 6; assert(oparg == CURRENT_OPARG()); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_1_r11: { + case _LOAD_FAST_BORROW_6_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 1; + oparg = 6; assert(oparg == CURRENT_OPARG()); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_1_r22: { + case _LOAD_FAST_BORROW_6_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 1; + oparg = 6; assert(oparg == CURRENT_OPARG()); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_1_r33: { + case _LOAD_FAST_BORROW_6_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 1; + oparg = 6; assert(oparg == CURRENT_OPARG()); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_2_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _LOAD_FAST_BORROW_6_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - oparg = 2; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 6; assert(oparg == CURRENT_OPARG()); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_2_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_FAST_BORROW_7_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 2; + oparg = 7; assert(oparg == CURRENT_OPARG()); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_2_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_BORROW_7_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 2; + oparg = 7; assert(oparg == CURRENT_OPARG()); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_2_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _LOAD_FAST_BORROW_7_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 2; + oparg = 7; assert(oparg == CURRENT_OPARG()); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_3_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - _PyStackRef trash; - oparg = 3; - assert(oparg == CURRENT_OPARG()); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _SWAP_FAST_3_r11: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - _PyStackRef trash; - _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 3; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _SWAP_FAST_3_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_FAST_BORROW_7_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 3; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 7; assert(oparg == CURRENT_OPARG()); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_3_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _LOAD_FAST_BORROW_7_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 3; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 7; assert(oparg == CURRENT_OPARG()); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_4_r01: { + case _LOAD_FAST_BORROW_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; + oparg = CURRENT_OPARG(); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_4_r11: { + case _LOAD_FAST_BORROW_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); + oparg = CURRENT_OPARG(); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_4_r22: { + case _LOAD_FAST_BORROW_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + oparg = CURRENT_OPARG(); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_4_r33: { + case _LOAD_FAST_BORROW_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + oparg = CURRENT_OPARG(); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_5_r01: { + case _LOAD_FAST_BORROW_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + assert(!PyStackRef_IsNull(GETLOCAL(oparg))); + value = PyStackRef_Borrow(GETLOCAL(oparg)); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_FAST_AND_CLEAR_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; + oparg = CURRENT_OPARG(); + value = GETLOCAL(oparg); + GETLOCAL(oparg) = PyStackRef_NULL; + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_5_r11: { + case _LOAD_FAST_AND_CLEAR_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); + oparg = CURRENT_OPARG(); + value = GETLOCAL(oparg); + GETLOCAL(oparg) = PyStackRef_NULL; + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_5_r22: { + case _LOAD_FAST_AND_CLEAR_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + oparg = CURRENT_OPARG(); + value = GETLOCAL(oparg); + GETLOCAL(oparg) = PyStackRef_NULL; + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_5_r33: { + case _LOAD_FAST_AND_CLEAR_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + oparg = CURRENT_OPARG(); + value = GETLOCAL(oparg); + GETLOCAL(oparg) = PyStackRef_NULL; + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_6_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _LOAD_FAST_AND_CLEAR_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + value = GETLOCAL(oparg); + GETLOCAL(oparg) = PyStackRef_NULL; + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_6_r11: { + case _LOAD_CONST_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + oparg = CURRENT_OPARG(); + PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg); + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_CONST_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); + oparg = CURRENT_OPARG(); + PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg); + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_6_r22: { + case _LOAD_CONST_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + oparg = CURRENT_OPARG(); + PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg); + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_6_r33: { + case _LOAD_CONST_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + oparg = CURRENT_OPARG(); + PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg); + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_7_r01: { + case _LOAD_CONST_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg); + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_SMALL_INT_0_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - oparg = 7; + oparg = 0; assert(oparg == CURRENT_OPARG()); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_7_r11: { + case _LOAD_SMALL_INT_0_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 7; + oparg = 0; assert(oparg == CURRENT_OPARG()); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_7_r22: { + case _LOAD_SMALL_INT_0_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 7; + oparg = 0; assert(oparg == CURRENT_OPARG()); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_7_r33: { + case _LOAD_SMALL_INT_0_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 7; + oparg = 0; assert(oparg == CURRENT_OPARG()); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _LOAD_SMALL_INT_0_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - oparg = CURRENT_OPARG(); - value = stack_pointer[-1]; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 0; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_SMALL_INT_1_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; - _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - value = _stack_item_0; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache0 = trash; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_SMALL_INT_1_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - value = _stack_item_1; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache1 = trash; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_FAST_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _LOAD_SMALL_INT_1_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - value = _stack_item_2; - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = value; - trash = tmp; - _tos_cache2 = trash; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_SMALL_INT_1_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_XCLOSE(value); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_NOP_r00: { + case _LOAD_SMALL_INT_1_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_SMALL_INT_2_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - value = stack_pointer[-1]; - assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || - _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_NOP_r10: { + case _LOAD_SMALL_INT_2_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || - _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); - SET_CURRENT_CACHED_VALUES(0); + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_NOP_r21: { + case _LOAD_SMALL_INT_2_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - value = _stack_item_1; - assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || - _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_NOP_r32: { + case _LOAD_SMALL_INT_2_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - value = _stack_item_2; - assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || - _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_INT_r00: { + case _LOAD_SMALL_INT_2_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 2; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_SMALL_INT_3_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - value = stack_pointer[-1]; - assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = 3; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_INT_r10: { + case _LOAD_SMALL_INT_3_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); - SET_CURRENT_CACHED_VALUES(0); + oparg = 3; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_INT_r21: { + case _LOAD_SMALL_INT_3_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - value = _stack_item_1; - assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); + oparg = 3; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_INT_r32: { + case _LOAD_SMALL_INT_3_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - value = _stack_item_2; - assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); + oparg = 3; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_FLOAT_r00: { + case _LOAD_SMALL_INT_3_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 3; + assert(oparg == CURRENT_OPARG()); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_SMALL_INT_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - value = stack_pointer[-1]; - assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = CURRENT_OPARG(); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_FLOAT_r10: { + case _LOAD_SMALL_INT_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); - SET_CURRENT_CACHED_VALUES(0); + oparg = CURRENT_OPARG(); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_FLOAT_r21: { + case _LOAD_SMALL_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - value = _stack_item_1; - assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); + oparg = CURRENT_OPARG(); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_FLOAT_r32: { + case _LOAD_SMALL_INT_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - value = _stack_item_2; - assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + oparg = CURRENT_OPARG(); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_UNICODE_r00: { + case _LOAD_SMALL_INT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + assert(oparg < _PY_NSMALLPOSINTS); + PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg]; + value = PyStackRef_FromPyObjectBorrow(obj); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SWAP_FAST_0_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; + oparg = 0; + assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_UNICODE_r10: { + case _SWAP_FAST_0_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; + oparg = 0; + assert(oparg == CURRENT_OPARG()); value = _stack_item_0; - assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_UNICODE_r21: { + case _SWAP_FAST_0_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 0; + assert(oparg == CURRENT_OPARG()); value = _stack_item_1; - assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_UNICODE_r32: { + case _SWAP_FAST_0_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 0; + assert(oparg == CURRENT_OPARG()); value = _stack_item_2; - assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); - PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TWO_r20: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SWAP_FAST_0_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - nos = _stack_item_0; - stack_pointer[0] = nos; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(tos); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(nos); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 0; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _PUSH_NULL_r01: { + case _SWAP_FAST_0_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef trash; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 0; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SWAP_FAST_1_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef res; - res = PyStackRef_NULL; - _tos_cache0 = res; + _PyStackRef value; + _PyStackRef trash; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + value = stack_pointer[-1]; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _PUSH_NULL_r12: { + case _SWAP_FAST_1_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef res; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - res = PyStackRef_NULL; - _tos_cache1 = res; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + oparg = 1; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_0; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _PUSH_NULL_r23: { + case _SWAP_FAST_1_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef res; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - res = PyStackRef_NULL; - _tos_cache2 = res; - _tos_cache1 = _stack_item_1; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_1; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _END_FOR_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SWAP_FAST_1_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(value); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_2; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_ITER_r20: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SWAP_FAST_1_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef index_or_null; - _PyStackRef iter; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - index_or_null = _stack_item_1; - iter = _stack_item_0; - (void)index_or_null; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(iter); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _END_SEND_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SWAP_FAST_1_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef receiver; - _PyStackRef val; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - value = _stack_item_1; - receiver = _stack_item_0; - val = value; - stack_pointer[0] = val; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(receiver); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = val; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _UNARY_NEGATIVE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - _PyStackRef res; - _PyStackRef v; - _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - stack_pointer[0] = value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNARY_NOT_r01: { + case _SWAP_FAST_2_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; + _PyStackRef trash; + oparg = 2; + assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - assert(PyStackRef_BoolCheck(value)); - res = PyStackRef_IsFalse(value) - ? PyStackRef_True : PyStackRef_False; - _tos_cache0 = res; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNARY_NOT_r11: { + case _SWAP_FAST_2_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; + oparg = 2; + assert(oparg == CURRENT_OPARG()); value = _stack_item_0; - assert(PyStackRef_BoolCheck(value)); - res = PyStackRef_IsFalse(value) - ? PyStackRef_True : PyStackRef_False; - _tos_cache0 = res; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNARY_NOT_r22: { + case _SWAP_FAST_2_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 2; + assert(oparg == CURRENT_OPARG()); value = _stack_item_1; - assert(PyStackRef_BoolCheck(value)); - res = PyStackRef_IsFalse(value) - ? PyStackRef_True : PyStackRef_False; - _tos_cache1 = res; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNARY_NOT_r33: { + case _SWAP_FAST_2_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 2; + assert(oparg == CURRENT_OPARG()); value = _stack_item_2; - assert(PyStackRef_BoolCheck(value)); - res = PyStackRef_IsFalse(value) - ? PyStackRef_True : PyStackRef_False; - _tos_cache2 = res; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SWAP_FAST_2_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - stack_pointer[0] = value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(value); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = err ? PyStackRef_True : PyStackRef_False; - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 2; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_BOOL_r01: { + case _SWAP_FAST_2_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef trash; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 2; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SWAP_FAST_3_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; + oparg = 3; + assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - if (!PyStackRef_BoolCheck(value)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(TO_BOOL, hit); - _tos_cache0 = value; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_BOOL_r11: { + case _SWAP_FAST_3_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; + oparg = 3; + assert(oparg == CURRENT_OPARG()); value = _stack_item_0; - if (!PyStackRef_BoolCheck(value)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(TO_BOOL, hit); - _tos_cache0 = value; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_BOOL_r22: { + case _SWAP_FAST_3_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 3; + assert(oparg == CURRENT_OPARG()); value = _stack_item_1; - if (!PyStackRef_BoolCheck(value)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(TO_BOOL, hit); - _tos_cache1 = value; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_BOOL_r33: { + case _SWAP_FAST_3_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 3; + assert(oparg == CURRENT_OPARG()); value = _stack_item_2; - if (!PyStackRef_BoolCheck(value)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = value; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(TO_BOOL, hit); - _tos_cache2 = value; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_INT_r02: { + case _SWAP_FAST_3_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef trash; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 3; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SWAP_FAST_3_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef trash; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 3; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SWAP_FAST_4_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; + _PyStackRef trash; + oparg = 4; + assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - STAT_INC(TO_BOOL, hit); - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - res = (_PyLong_IsZero((PyLongObject *)value_o)) ? PyStackRef_False : PyStackRef_True; - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_INT_r12: { + case _SWAP_FAST_4_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; + oparg = 4; + assert(oparg == CURRENT_OPARG()); value = _stack_item_0; - STAT_INC(TO_BOOL, hit); - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - res = (_PyLong_IsZero((PyLongObject *)value_o)) ? PyStackRef_False : PyStackRef_True; - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_INT_r23: { + case _SWAP_FAST_4_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 4; + assert(oparg == CURRENT_OPARG()); value = _stack_item_1; - STAT_INC(TO_BOOL, hit); - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - res = (_PyLong_IsZero((PyLongObject *)value_o)) ? PyStackRef_False : PyStackRef_True; - v = value; - _tos_cache2 = v; - _tos_cache1 = res; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_LIST_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - nos = stack_pointer[-2]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyList_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = nos; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_LIST_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SWAP_FAST_4_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - nos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyList_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_0; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_2; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_LIST_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SWAP_FAST_4_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - nos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyList_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_LIST_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SWAP_FAST_4_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - nos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyList_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_LIST_r01: { + case _SWAP_FAST_5_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - tos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyList_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; + _PyStackRef value; + _PyStackRef trash; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + value = stack_pointer[-1]; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_LIST_r11: { + case _SWAP_FAST_5_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - tos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyList_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_0; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_LIST_r22: { + case _SWAP_FAST_5_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyList_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = tos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = tos; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_1; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_LIST_r33: { + case _SWAP_FAST_5_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - tos = _stack_item_2; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyList_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = tos; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = tos; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_2; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_SLICE_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - tos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PySlice_Check(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TOS_SLICE_r11: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - _PyStackRef _stack_item_0 = _tos_cache0; - tos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PySlice_Check(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TOS_SLICE_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SWAP_FAST_5_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PySlice_Check(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = tos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = tos; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_SLICE_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SWAP_FAST_5_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - tos = _stack_item_2; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PySlice_Check(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = tos; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = tos; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_LIST_r02: { + case _SWAP_FAST_6_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; + _PyStackRef trash; + oparg = 6; + assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - assert(PyList_CheckExact(value_o)); - STAT_INC(TO_BOOL, hit); - res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_LIST_r12: { + case _SWAP_FAST_6_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; + oparg = 6; + assert(oparg == CURRENT_OPARG()); value = _stack_item_0; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - assert(PyList_CheckExact(value_o)); - STAT_INC(TO_BOOL, hit); - res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_LIST_r23: { + case _SWAP_FAST_6_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 6; + assert(oparg == CURRENT_OPARG()); value = _stack_item_1; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - assert(PyList_CheckExact(value_o)); - STAT_INC(TO_BOOL, hit); - res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; - v = value; - _tos_cache2 = v; - _tos_cache1 = res; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _TO_BOOL_NONE_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - _PyStackRef res; - value = stack_pointer[-1]; - if (!PyStackRef_IsNone(value)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(TO_BOOL, hit); - res = PyStackRef_False; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_NONE_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SWAP_FAST_6_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - if (!PyStackRef_IsNone(value)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(TO_BOOL, hit); - res = PyStackRef_False; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_2; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_NONE_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SWAP_FAST_6_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - value = _stack_item_1; - if (!PyStackRef_IsNone(value)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(TO_BOOL, hit); - res = PyStackRef_False; - _tos_cache1 = res; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_NONE_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SWAP_FAST_6_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - value = _stack_item_2; - if (!PyStackRef_IsNone(value)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = value; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(TO_BOOL, hit); - res = PyStackRef_False; - _tos_cache2 = res; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_COMPACT_ASCII_r02: { + case _SWAP_FAST_7_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - nos = stack_pointer[-2]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyUnicode_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (!PyUnicode_IS_COMPACT_ASCII(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; + _PyStackRef value; + _PyStackRef trash; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + value = stack_pointer[-1]; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_COMPACT_ASCII_r12: { + case _SWAP_FAST_7_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - nos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyUnicode_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (!PyUnicode_IS_COMPACT_ASCII(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_0; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = 7; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_0; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_COMPACT_ASCII_r22: { + case _SWAP_FAST_7_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - nos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyUnicode_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - if (!PyUnicode_IS_COMPACT_ASCII(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_1; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_COMPACT_ASCII_r33: { + case _SWAP_FAST_7_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - nos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyUnicode_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - if (!PyUnicode_IS_COMPACT_ASCII(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_2; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_UNICODE_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - nos = stack_pointer[-2]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyUnicode_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_UNICODE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SWAP_FAST_7_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - nos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyUnicode_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_0; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_UNICODE_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SWAP_FAST_7_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - nos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyUnicode_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_UNICODE_r33: { - CHECK_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - nos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyUnicode_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TOS_UNICODE_r01: { + case _SWAP_FAST_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; + oparg = CURRENT_OPARG(); value = stack_pointer[-1]; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyUnicode_CheckExact(value_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = value; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_UNICODE_r11: { + case _SWAP_FAST_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); value = _stack_item_0; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyUnicode_CheckExact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = value; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache0 = trash; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_UNICODE_r22: { + case _SWAP_FAST_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); value = _stack_item_1; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyUnicode_CheckExact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = value; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache1 = trash; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_UNICODE_r33: { + case _SWAP_FAST_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); value = _stack_item_2; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyUnicode_CheckExact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = value; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = value; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache2 = trash; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_STR_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SWAP_FAST_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; - value = stack_pointer[-1]; - STAT_INC(TO_BOOL, hit); - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - res = value_o == &_Py_STR(empty) ? PyStackRef_False : PyStackRef_True; - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef trash; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + value = _stack_item_3; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache3 = trash; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_STR_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SWAP_FAST_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; + _PyStackRef trash; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - STAT_INC(TO_BOOL, hit); - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - res = value_o == &_Py_STR(empty) ? PyStackRef_False : PyStackRef_True; - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = CURRENT_OPARG(); + value = _stack_item_4; + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = value; + trash = tmp; + _tos_cache4 = trash; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _TO_BOOL_STR_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _POP_TOP_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - value = _stack_item_1; - STAT_INC(TO_BOOL, hit); - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - res = value_o == &_Py_STR(empty) ? PyStackRef_False : PyStackRef_True; - v = value; - _tos_cache2 = v; - _tos_cache1 = res; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + value = _stack_item_0; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_XCLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _REPLACE_WITH_TRUE_r02: { + case _POP_TOP_NOP_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; value = stack_pointer[-1]; - res = PyStackRef_True; - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || + _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); + SET_CURRENT_CACHED_VALUES(0); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _REPLACE_WITH_TRUE_r12: { + case _POP_TOP_NOP_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; value = _stack_item_0; - res = PyStackRef_True; - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || + _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _REPLACE_WITH_TRUE_r23: { + case _POP_TOP_NOP_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; value = _stack_item_1; - res = PyStackRef_True; - v = value; - _tos_cache2 = v; - _tos_cache1 = res; + assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || + _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNARY_INVERT_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _POP_TOP_NOP_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - _PyStackRef res; - _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - stack_pointer[0] = value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - v = value; - _tos_cache1 = v; - _tos_cache0 = res; - _tos_cache2 = PyStackRef_ZERO_BITS; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || + _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_INT_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _POP_TOP_NOP_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - if (!_PyLong_CheckExactAndCompact(left_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_INT_r12: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - _PyStackRef _stack_item_0 = _tos_cache0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - if (!_PyLong_CheckExactAndCompact(left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_0; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_INT_r22: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - if (!_PyLong_CheckExactAndCompact(left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || + _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_INT_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _POP_TOP_NOP_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - left = _stack_item_1; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - if (!_PyLong_CheckExactAndCompact(left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = left; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) || + _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value)))); + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; - _tos_cache1 = left; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_INT_r01: { + case _POP_TOP_INT_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; value = stack_pointer[-1]; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!_PyLong_CheckExactAndCompact(value_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); + assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); + SET_CURRENT_CACHED_VALUES(0); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _GUARD_TOS_INT_r11: { + case _POP_TOP_INT_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; value = _stack_item_0; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!_PyLong_CheckExactAndCompact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); + assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_INT_r22: { + case _POP_TOP_INT_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; value = _stack_item_1; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!_PyLong_CheckExactAndCompact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = value; + assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_INT_r33: { + case _POP_TOP_INT_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -3913,180 +4969,118 @@ _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; value = _stack_item_2; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!_PyLong_CheckExactAndCompact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = value; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = value; + assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_OVERFLOWED_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - assert(Py_TYPE(left_o) == &PyLong_Type); - if (!_PyLong_IsCompact((PyLongObject *)left_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_OVERFLOWED_r12: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - _PyStackRef _stack_item_0 = _tos_cache0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - assert(Py_TYPE(left_o) == &PyLong_Type); - if (!_PyLong_IsCompact((PyLongObject *)left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_0; - _tos_cache0 = left; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_OVERFLOWED_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _POP_TOP_INT_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - assert(Py_TYPE(left_o) == &PyLong_Type); - if (!_PyLong_IsCompact((PyLongObject *)left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_OVERFLOWED_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _POP_TOP_INT_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - left = _stack_item_1; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - assert(Py_TYPE(left_o) == &PyLong_Type); - if (!_PyLong_IsCompact((PyLongObject *)left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = left; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc); + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; - _tos_cache1 = left; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_OVERFLOWED_r01: { + case _POP_TOP_FLOAT_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; value = stack_pointer[-1]; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - assert(Py_TYPE(value_o) == &PyLong_Type); - if (!_PyLong_IsCompact((PyLongObject *)value_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); + assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); + SET_CURRENT_CACHED_VALUES(0); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _GUARD_TOS_OVERFLOWED_r11: { + case _POP_TOP_FLOAT_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; value = _stack_item_0; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - assert(Py_TYPE(value_o) == &PyLong_Type); - if (!_PyLong_IsCompact((PyLongObject *)value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); + assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_OVERFLOWED_r22: { + case _POP_TOP_FLOAT_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; value = _stack_item_1; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - assert(Py_TYPE(value_o) == &PyLong_Type); - if (!_PyLong_IsCompact((PyLongObject *)value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = value; + assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_OVERFLOWED_r33: { + case _POP_TOP_FLOAT_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; @@ -4094,1559 +5088,1139 @@ _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; value = _stack_item_2; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - assert(Py_TYPE(value_o) == &PyLong_Type); - if (!_PyLong_IsCompact((PyLongObject *)value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = value; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = value; + assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _BINARY_OP_MULTIPLY_INT_r03: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_MULTIPLY_INT_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _POP_TOP_FLOAT_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = right; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_MULTIPLY_INT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _POP_TOP_FLOAT_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = right; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_ADD_INT_r03: { + case _POP_TOP_UNICODE_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + _PyStackRef value; + value = stack_pointer[-1]; + assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _BINARY_OP_ADD_INT_r13: { + case _POP_TOP_UNICODE_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = right; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + value = _stack_item_0; + assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_ADD_INT_r23: { + case _POP_TOP_UNICODE_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = right; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + value = _stack_item_1; + assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBTRACT_INT_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _POP_TOP_UNICODE_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBTRACT_INT_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _POP_TOP_UNICODE_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = right; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBTRACT_INT_r23: { + case _POP_TOP_UNICODE_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value))); + PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _POP_TWO_r20: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef tos; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyLong_CheckExact(left_o)); - assert(PyLong_CheckExact(right_o)); - assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); - STAT_INC(BINARY_OP, hit); - res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); - if (PyStackRef_IsNull(res)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = right; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + tos = _stack_item_1; + nos = _stack_item_0; + stack_pointer[0] = nos; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(tos); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(nos); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_FLOAT_r02: { + case _PUSH_NULL_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - if (!PyFloat_CheckExact(left_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef res; + res = PyStackRef_NULL; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_FLOAT_r12: { + case _PUSH_NULL_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; + _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - if (!PyFloat_CheckExact(left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_0; - _tos_cache0 = left; + res = PyStackRef_NULL; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_FLOAT_r22: { + case _PUSH_NULL_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; + _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - if (!PyFloat_CheckExact(left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + res = PyStackRef_NULL; + _tos_cache2 = res; _tos_cache1 = _stack_item_1; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_FLOAT_r33: { + case _PUSH_NULL_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; + _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - left = _stack_item_1; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - if (!PyFloat_CheckExact(left_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = left; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + res = PyStackRef_NULL; + _tos_cache3 = res; _tos_cache2 = _stack_item_2; - _tos_cache1 = left; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FLOAT_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _PUSH_NULL_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - value = stack_pointer[-1]; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyFloat_CheckExact(value_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + res = PyStackRef_NULL; + _tos_cache4 = res; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FLOAT_r11: { + case _END_FOR_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; value = _stack_item_0; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyFloat_CheckExact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FLOAT_r22: { + case _POP_ITER_r20: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; + _PyStackRef index_or_null; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - value = _stack_item_1; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyFloat_CheckExact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + index_or_null = _stack_item_1; + iter = _stack_item_0; + (void)index_or_null; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(iter); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FLOAT_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _END_SEND_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; + _PyStackRef receiver; + _PyStackRef val; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - value = _stack_item_2; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyFloat_CheckExact(value_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = value; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = value; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + value = _stack_item_1; + receiver = _stack_item_0; + val = value; + stack_pointer[0] = val; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(receiver); + stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache0 = val; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_MULTIPLY_FLOAT_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _UNARY_NEGATIVE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval * - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { + _PyStackRef v; + _PyStackRef _stack_item_0 = _tos_cache0; + value = _stack_item_0; + stack_pointer[0] = value; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; + res = PyStackRef_FromPyObjectSteal(res_o); + v = value; + _tos_cache1 = v; _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_MULTIPLY_FLOAT_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _UNARY_NOT_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - _PyStackRef _stack_item_0 = _tos_cache0; - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval * - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = right; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; + value = stack_pointer[-1]; + assert(PyStackRef_BoolCheck(value)); + res = PyStackRef_IsFalse(value) + ? PyStackRef_True : PyStackRef_False; _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_MULTIPLY_FLOAT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _UNARY_NOT_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval * - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; + value = _stack_item_0; + assert(PyStackRef_BoolCheck(value)); + res = PyStackRef_IsFalse(value) + ? PyStackRef_True : PyStackRef_False; _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_ADD_FLOAT_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _UNARY_NOT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval + - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + value = _stack_item_1; + assert(PyStackRef_BoolCheck(value)); + res = PyStackRef_IsFalse(value) + ? PyStackRef_True : PyStackRef_False; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_ADD_FLOAT_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _UNARY_NOT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval + - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = right; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + assert(PyStackRef_BoolCheck(value)); + res = PyStackRef_IsFalse(value) + ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_ADD_FLOAT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _UNARY_NOT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval + - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + assert(PyStackRef_BoolCheck(value)); + res = PyStackRef_IsFalse(value) + ? PyStackRef_True : PyStackRef_False; + _tos_cache3 = res; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBTRACT_FLOAT_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _UNARY_NOT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval - - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + assert(PyStackRef_BoolCheck(value)); + res = PyStackRef_IsFalse(value) + ? PyStackRef_True : PyStackRef_False; + _tos_cache4 = res; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBTRACT_FLOAT_r13: { + case _TO_BOOL_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval - - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = right; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + value = _stack_item_0; + stack_pointer[0] = value; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; + res = err ? PyStackRef_True : PyStackRef_False; _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBTRACT_FLOAT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_BOOL_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyFloat_CheckExact(left_o)); - assert(PyFloat_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - double dres = - ((PyFloatObject *)left_o)->ob_fval - - ((PyFloatObject *)right_o)->ob_fval; - res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef value; + value = stack_pointer[-1]; + if (!PyStackRef_BoolCheck(value)) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + JUMP_TO_JUMP_TARGET(); } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + STAT_INC(TO_BOOL, hit); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_ADD_UNICODE_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _TO_BOOL_BOOL_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyUnicode_CheckExact(left_o)); - assert(PyUnicode_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - PyObject *res_o = PyUnicode_Concat(left_o, right_o); - res = PyStackRef_FromPyObjectSteal(res_o); - if (PyStackRef_IsNull(res)) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + value = _stack_item_0; + if (!PyStackRef_BoolCheck(value)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + STAT_INC(TO_BOOL, hit); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_ADD_UNICODE_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _TO_BOOL_BOOL_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyUnicode_CheckExact(left_o)); - assert(PyUnicode_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - PyObject *res_o = PyUnicode_Concat(left_o, right_o); - res = PyStackRef_FromPyObjectSteal(res_o); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = right; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_1 = _tos_cache1; + value = _stack_item_1; + if (!PyStackRef_BoolCheck(value)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + STAT_INC(TO_BOOL, hit); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_ADD_UNICODE_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_BOOL_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyUnicode_CheckExact(left_o)); - assert(PyUnicode_CheckExact(right_o)); - STAT_INC(BINARY_OP, hit); - PyObject *res_o = PyUnicode_Concat(left_o, right_o); - res = PyStackRef_FromPyObjectSteal(res_o); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + if (!PyStackRef_BoolCheck(value)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; + STAT_INC(TO_BOOL, hit); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_INPLACE_ADD_UNICODE_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_BOOL_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - assert(PyUnicode_CheckExact(left_o)); - assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(right))); - int next_oparg; - #if TIER_ONE - assert(next_instr->op.code == STORE_FAST); - next_oparg = next_instr->op.arg; - #else - next_oparg = (int)CURRENT_OPERAND0_16(); - #endif - _PyStackRef *target_local = &GETLOCAL(next_oparg); - assert(PyUnicode_CheckExact(left_o)); - if (PyStackRef_AsPyObjectBorrow(*target_local) != left_o) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + if (!PyStackRef_BoolCheck(value)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = right; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - STAT_INC(BINARY_OP, hit); - assert(Py_REFCNT(left_o) >= 2 || !PyStackRef_IsHeapSafe(left)); - PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local); - PyObject *right_o = PyStackRef_AsPyObjectSteal(right); - PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyUnicode_Append(&temp, right_o); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - stack_pointer = _PyFrame_GetStackPointer(frame); - *target_local = PyStackRef_NULL; - if (temp == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(temp); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + STAT_INC(TO_BOOL, hit); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BINARY_OP_EXTEND_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_BOOL_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - _PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr*)descr; - assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5); - assert(d && d->guard); - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int res = d->guard(left_o, right_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (!res) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + if (!PyStackRef_BoolCheck(value)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = right; - _tos_cache0 = left; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = right; - _tos_cache0 = left; - _tos_cache2 = PyStackRef_ZERO_BITS; + STAT_INC(TO_BOOL, hit); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _TO_BOOL_INT_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; + value = stack_pointer[-1]; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = (_PyLong_IsZero((PyLongObject *)value_o)) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache1 = v; + _tos_cache0 = res; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_EXTEND_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_INT_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; + _PyStackRef value; _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5); - _PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr*)descr; - STAT_INC(BINARY_OP, hit); - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = d->action(left_o, right_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; + value = _stack_item_0; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = (_PyLong_IsZero((PyLongObject *)value_o)) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache1 = v; _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_SLICE_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _TO_BOOL_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef stop; - _PyStackRef start; - _PyStackRef container; + _PyStackRef value; _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - stop = _stack_item_2; - start = _stack_item_1; - container = _stack_item_0; - PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); - PyObject *start_o = PyStackRef_AsPyObjectBorrow(start); - PyObject *stop_o = PyStackRef_AsPyObjectBorrow(stop); - PyObject *res_o; - if (PyList_CheckExact(container_o)) { - stack_pointer[0] = container; - stack_pointer[1] = start; - stack_pointer[2] = stop; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = _PyList_BinarySlice(container_o, start_o, stop_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else if (PyTuple_CheckExact(container_o)) { - stack_pointer[0] = container; - stack_pointer[1] = start; - stack_pointer[2] = stop; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = _PyTuple_BinarySlice(container_o, start_o, stop_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else if (PyUnicode_CheckExact(container_o)) { - stack_pointer[0] = container; - stack_pointer[1] = start; - stack_pointer[2] = stop; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = _PyUnicode_BinarySlice(container_o, start_o, stop_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else { - PyObject *slice = PySlice_New(start_o, stop_o, NULL); - if (slice == NULL) { - res_o = NULL; - } - else { - stack_pointer[0] = container; - stack_pointer[1] = start; - stack_pointer[2] = stop; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = PyObject_GetItem(container_o, slice); - Py_DECREF(slice); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -3; - } - stack_pointer += 3; - } - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp = stop; - stop = PyStackRef_NULL; - stack_pointer[-3] = container; - stack_pointer[-2] = start; - stack_pointer[-1] = stop; - PyStackRef_CLOSE(tmp); - tmp = start; - start = PyStackRef_NULL; - stack_pointer[-2] = start; - PyStackRef_CLOSE(tmp); - tmp = container; - container = PyStackRef_NULL; - stack_pointer[-3] = container; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + value = _stack_item_1; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = (_PyLong_IsZero((PyLongObject *)value_o)) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache2 = v; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_SLICE_r30: { + case _TO_BOOL_INT_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef stop; - _PyStackRef start; - _PyStackRef container; + _PyStackRef value; + _PyStackRef res; _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - stop = _stack_item_2; - start = _stack_item_1; - container = _stack_item_0; - v = stack_pointer[-1]; - stack_pointer[0] = container; - stack_pointer[1] = start; - stack_pointer[2] = stop; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), - PyStackRef_AsPyObjectSteal(stop)); - stack_pointer = _PyFrame_GetStackPointer(frame); - int err; - if (slice == NULL) { - err = 1; - } - else { - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); - Py_DECREF(slice); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += 2; - } - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp = container; - container = PyStackRef_NULL; - stack_pointer[-3] = container; - PyStackRef_CLOSE(tmp); - tmp = v; - v = PyStackRef_NULL; - stack_pointer[-4] = v; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -4; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + value = _stack_item_2; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = (_PyLong_IsZero((PyLongObject *)value_o)) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache3 = v; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_LIST_INT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_INT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef list_st; + _PyStackRef value; _PyStackRef res; - _PyStackRef ls; - _PyStackRef ss; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - sub_st = _stack_item_1; - list_st = _stack_item_0; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); - assert(PyLong_CheckExact(sub)); - assert(PyList_CheckExact(list)); - if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = (_PyLong_IsZero((PyLongObject *)value_o)) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache4 = v; + _tos_cache3 = res; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_LIST_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + nos = stack_pointer[-2]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = list_st; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - #ifdef Py_GIL_DISABLED - stack_pointer[0] = list_st; - stack_pointer[1] = sub_st; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyList_GetItemRef((PyListObject*)list, index); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = list_st; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(BINARY_OP, hit); - res = PyStackRef_FromPyObjectSteal(res_o); - #else - if (index >= PyList_GET_SIZE(list)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = list_st; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(BINARY_OP, hit); - PyObject *res_o = PyList_GET_ITEM(list, index); - assert(res_o != NULL); - res = PyStackRef_FromPyObjectNew(res_o); - stack_pointer += 2; - #endif - STAT_INC(BINARY_OP, hit); - ls = list_st; - ss = sub_st; - _tos_cache2 = ss; - _tos_cache1 = ls; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _BINARY_OP_SUBSCR_LIST_SLICE_r23: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef list_st; - _PyStackRef res; - _PyStackRef ls; - _PyStackRef ss; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - sub_st = _stack_item_1; - list_st = _stack_item_0; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); - assert(PySlice_Check(sub)); - assert(PyList_CheckExact(list)); - stack_pointer[0] = list_st; - stack_pointer[1] = sub_st; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyList_SliceSubscript(list, sub); - stack_pointer = _PyFrame_GetStackPointer(frame); - STAT_INC(BINARY_OP, hit); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - ls = list_st; - ss = sub_st; - _tos_cache2 = ss; - _tos_cache1 = ls; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_STR_INT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_NOS_LIST_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef str_st; - _PyStackRef res; - _PyStackRef s; - _PyStackRef i; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - sub_st = _stack_item_1; - str_st = _stack_item_0; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *str = PyStackRef_AsPyObjectBorrow(str_st); - assert(PyLong_CheckExact(sub)); - assert(PyUnicode_CheckExact(str)); - if (!_PyLong_IsNonNegativeCompact((PyLongObject*)sub)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = str_st; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - if (PyUnicode_GET_LENGTH(str) <= index) { + nos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = str_st; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - uint8_t c = PyUnicode_1BYTE_DATA(str)[index]; - assert(c < 128); - STAT_INC(BINARY_OP, hit); - PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; - s = str_st; - i = sub_st; - res = PyStackRef_FromPyObjectBorrow(res_o); - _tos_cache2 = i; - _tos_cache1 = s; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache1 = _stack_item_0; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_USTR_INT_r23: { + case _GUARD_NOS_LIST_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef str_st; - _PyStackRef res; - _PyStackRef s; - _PyStackRef i; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - sub_st = _stack_item_1; - str_st = _stack_item_0; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *str = PyStackRef_AsPyObjectBorrow(str_st); - assert(PyLong_CheckExact(sub)); - assert(PyUnicode_CheckExact(str)); - if (!_PyLong_IsNonNegativeCompact((PyLongObject*)sub)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = str_st; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - if (PyUnicode_GET_LENGTH(str) <= index) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = str_st; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - Py_UCS4 c = PyUnicode_READ_CHAR(str, index); - if (Py_ARRAY_LENGTH(_Py_SINGLETON(strings).ascii) <= c) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = str_st; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(BINARY_OP, hit); - PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; - s = str_st; - i = sub_st; - res = PyStackRef_FromPyObjectBorrow(res_o); - _tos_cache2 = i; - _tos_cache1 = s; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_TUPLE_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - nos = stack_pointer[-2]; + nos = _stack_item_0; PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyTuple_CheckExact(o)) { + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = stack_pointer[-1]; + _tos_cache1 = _stack_item_1; _tos_cache0 = nos; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_TUPLE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_NOS_LIST_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; - nos = stack_pointer[-1]; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + nos = _stack_item_1; PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyTuple_CheckExact(o)) { + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_0; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_TUPLE_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_NOS_LIST_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - nos = _stack_item_0; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + nos = _stack_item_2; PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyTuple_CheckExact(o)) { + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_TUPLE_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_NOS_LIST_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - nos = _stack_item_1; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + nos = _stack_item_3; PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyTuple_CheckExact(o)) { + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_TUPLE_r01: { + case _GUARD_TOS_LIST_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef tos; tos = stack_pointer[-1]; PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyTuple_CheckExact(o)) { + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); @@ -5657,16 +6231,20 @@ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_TUPLE_r11: { + case _GUARD_TOS_LIST_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef tos; _PyStackRef _stack_item_0 = _tos_cache0; tos = _stack_item_0; PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyTuple_CheckExact(o)) { + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = tos; SET_CURRENT_CACHED_VALUES(1); @@ -5676,9 +6254,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_TUPLE_r22: { + case _GUARD_TOS_LIST_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef tos; @@ -5686,7 +6268,7 @@ _PyStackRef _stack_item_1 = _tos_cache1; tos = _stack_item_1; PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyTuple_CheckExact(o)) { + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = tos; _tos_cache0 = _stack_item_0; @@ -5698,9 +6280,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_TUPLE_r33: { + case _GUARD_TOS_LIST_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef tos; @@ -5709,7 +6295,7 @@ _PyStackRef _stack_item_2 = _tos_cache2; tos = _stack_item_2; PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyTuple_CheckExact(o)) { + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); _tos_cache2 = tos; _tos_cache1 = _stack_item_1; @@ -5723,4244 +6309,16195 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_TOS_LIST_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef tuple_st; - sub_st = stack_pointer[-1]; - tuple_st = stack_pointer[-2]; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); - assert(PyLong_CheckExact(sub)); - assert(PyTuple_CheckExact(tuple)); - if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyList_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - if (index >= PyTuple_GET_SIZE(tuple)) { + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_LIST_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyList_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_SLICE_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + tos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySlice_Check(o)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = sub_st; - _tos_cache0 = tuple_st; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12: { + case _GUARD_TOS_SLICE_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef tuple_st; + _PyStackRef tos; _PyStackRef _stack_item_0 = _tos_cache0; - sub_st = _stack_item_0; - tuple_st = stack_pointer[-1]; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); - assert(PyLong_CheckExact(sub)); - assert(PyTuple_CheckExact(tuple)); - if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = sub_st; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - if (index >= PyTuple_GET_SIZE(tuple)) { + tos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySlice_Check(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = sub_st; + _tos_cache0 = tos; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = sub_st; - _tos_cache0 = tuple_st; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22: { + case _GUARD_TOS_SLICE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef tuple_st; + _PyStackRef tos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - sub_st = _stack_item_1; - tuple_st = _stack_item_0; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); - assert(PyLong_CheckExact(sub)); - assert(PyTuple_CheckExact(tuple)); - if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = tuple_st; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - if (index >= PyTuple_GET_SIZE(tuple)) { + tos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySlice_Check(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = sub_st; - _tos_cache0 = tuple_st; + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = sub_st; - _tos_cache0 = tuple_st; + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33: { + case _GUARD_TOS_SLICE_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef tuple_st; + _PyStackRef tos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - sub_st = _stack_item_2; - tuple_st = _stack_item_1; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); - assert(PyLong_CheckExact(sub)); - assert(PyTuple_CheckExact(tuple)); - if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + tos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySlice_Check(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = sub_st; - _tos_cache1 = tuple_st; + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - if (index >= PyTuple_GET_SIZE(tuple)) { + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_SLICE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySlice_Check(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = sub_st; - _tos_cache1 = tuple_st; + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = sub_st; - _tos_cache1 = tuple_st; + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_TUPLE_INT_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_TOS_SLICE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef tuple_st; - _PyStackRef res; - _PyStackRef ts; - _PyStackRef ss; - sub_st = stack_pointer[-1]; - tuple_st = stack_pointer[-2]; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); - assert(PyLong_CheckExact(sub)); - assert(PyTuple_CheckExact(tuple)); - STAT_INC(BINARY_OP, hit); - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - PyObject *res_o = PyTuple_GET_ITEM(tuple, index); - assert(res_o != NULL); - res = PyStackRef_FromPyObjectNew(res_o); - ts = tuple_st; - ss = sub_st; - _tos_cache2 = ss; - _tos_cache1 = ts; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySlice_Check(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_TUPLE_INT_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _TO_BOOL_LIST_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef tuple_st; + _PyStackRef value; _PyStackRef res; - _PyStackRef ts; - _PyStackRef ss; - _PyStackRef _stack_item_0 = _tos_cache0; - sub_st = _stack_item_0; - tuple_st = stack_pointer[-1]; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); - assert(PyLong_CheckExact(sub)); - assert(PyTuple_CheckExact(tuple)); - STAT_INC(BINARY_OP, hit); - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - PyObject *res_o = PyTuple_GET_ITEM(tuple, index); - assert(res_o != NULL); - res = PyStackRef_FromPyObjectNew(res_o); - ts = tuple_st; - ss = sub_st; - _tos_cache2 = ss; - _tos_cache1 = ts; + _PyStackRef v; + value = stack_pointer[-1]; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(PyList_CheckExact(value_o)); + STAT_INC(TO_BOOL, hit); + res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; + v = value; + _tos_cache1 = v; _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(2); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_TUPLE_INT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_LIST_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef tuple_st; + _PyStackRef value; _PyStackRef res; - _PyStackRef ts; - _PyStackRef ss; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - sub_st = _stack_item_1; - tuple_st = _stack_item_0; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); - assert(PyLong_CheckExact(sub)); - assert(PyTuple_CheckExact(tuple)); - STAT_INC(BINARY_OP, hit); - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - PyObject *res_o = PyTuple_GET_ITEM(tuple, index); - assert(res_o != NULL); - res = PyStackRef_FromPyObjectNew(res_o); - ts = tuple_st; - ss = sub_st; - _tos_cache2 = ss; - _tos_cache1 = ts; + value = _stack_item_0; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(PyList_CheckExact(value_o)); + STAT_INC(TO_BOOL, hit); + res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; + v = value; + _tos_cache1 = v; _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_DICT_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - nos = stack_pointer[-2]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyDict_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = nos; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_DICT_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _TO_BOOL_LIST_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - nos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyDict_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_0; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_1 = _tos_cache1; + value = _stack_item_1; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(PyList_CheckExact(value_o)); + STAT_INC(TO_BOOL, hit); + res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; + v = value; + _tos_cache2 = v; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_DICT_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_LIST_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - nos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyDict_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(PyList_CheckExact(value_o)); + STAT_INC(TO_BOOL, hit); + res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; + v = value; + _tos_cache3 = v; + _tos_cache2 = res; _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_DICT_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _TO_BOOL_LIST_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - nos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyDict_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(PyList_CheckExact(value_o)); + STAT_INC(TO_BOOL, hit); + res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; + v = value; + _tos_cache4 = v; + _tos_cache3 = res; _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_ANY_DICT_r02: { + case _TO_BOOL_NONE_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - nos = stack_pointer[-2]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyAnyDict_CheckExact(o)) { + _PyStackRef value; + _PyStackRef res; + value = stack_pointer[-1]; + if (!PyStackRef_IsNone(value)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; + STAT_INC(TO_BOOL, hit); + res = PyStackRef_False; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_ANY_DICT_r12: { + case _TO_BOOL_NONE_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; - nos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyAnyDict_CheckExact(o)) { + value = _stack_item_0; + if (!PyStackRef_IsNone(value)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_0; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + STAT_INC(TO_BOOL, hit); + res = PyStackRef_False; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_ANY_DICT_r22: { + case _TO_BOOL_NONE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - nos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyAnyDict_CheckExact(o)) { + value = _stack_item_1; + if (!PyStackRef_IsNone(value)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; + STAT_INC(TO_BOOL, hit); + res = PyStackRef_False; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_ANY_DICT_r33: { + case _TO_BOOL_NONE_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef value; + _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - nos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (!PyAnyDict_CheckExact(o)) { + value = _stack_item_2; + if (!PyStackRef_IsNone(value)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; + STAT_INC(TO_BOOL, hit); + res = PyStackRef_False; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_ANY_DICT_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - tos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyAnyDict_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TOS_ANY_DICT_r11: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - _PyStackRef _stack_item_0 = _tos_cache0; - tos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyAnyDict_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TOS_ANY_DICT_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_NONE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef value; + _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyAnyDict_CheckExact(o)) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + if (!PyStackRef_IsNone(value)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = tos; + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = tos; + STAT_INC(TO_BOOL, hit); + res = PyStackRef_False; + _tos_cache3 = res; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_ANY_DICT_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _TO_BOOL_NONE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef value; + _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - tos = _stack_item_2; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyAnyDict_CheckExact(o)) { + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + if (!PyStackRef_IsNone(value)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = tos; + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = tos; + STAT_INC(TO_BOOL, hit); + res = PyStackRef_False; + _tos_cache4 = res; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_DICT_r01: { + case _GUARD_NOS_COMPACT_ASCII_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - tos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyDict_CheckExact(o)) { + _PyStackRef nos; + nos = stack_pointer[-2]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; + if (!PyUnicode_IS_COMPACT_ASCII(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_DICT_r11: { + case _GUARD_NOS_COMPACT_ASCII_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; - tos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyDict_CheckExact(o)) { + nos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = tos; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); + if (!PyUnicode_IS_COMPACT_ASCII(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_0; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_DICT_r22: { + case _GUARD_NOS_COMPACT_ASCII_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyDict_CheckExact(o)) { + nos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = tos; - _tos_cache0 = _stack_item_0; + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = tos; - _tos_cache0 = _stack_item_0; + if (!PyUnicode_IS_COMPACT_ASCII(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_DICT_r33: { + case _GUARD_NOS_COMPACT_ASCII_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - tos = _stack_item_2; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyDict_CheckExact(o)) { + nos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = tos; - _tos_cache1 = _stack_item_1; + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = tos; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TOS_FROZENDICT_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - tos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyFrozenDict_CheckExact(o)) { + if (!PyUnicode_IS_COMPACT_ASCII(o)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FROZENDICT_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_NOS_COMPACT_ASCII_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; - tos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyFrozenDict_CheckExact(o)) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + nos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TOS_FROZENDICT_r22: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyFrozenDict_CheckExact(o)) { + if (!PyUnicode_IS_COMPACT_ASCII(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FROZENDICT_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_NOS_COMPACT_ASCII_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - tos = _stack_item_2; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyFrozenDict_CheckExact(o)) { + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + nos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = tos; + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = tos; + if (!PyUnicode_IS_COMPACT_ASCII(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_DICT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_NOS_UNICODE_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef dict_st; - _PyStackRef res; - _PyStackRef ds; - _PyStackRef ss; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - sub_st = _stack_item_1; - dict_st = _stack_item_0; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); - assert(PyAnyDict_CheckExact(dict)); - STAT_INC(BINARY_OP, hit); - PyObject *res_o; - stack_pointer[0] = dict_st; - stack_pointer[1] = sub_st; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int rc = PyDict_GetItemRef(dict, sub, &res_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (rc == 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetKeyError(sub); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - if (rc <= 0) { + _PyStackRef nos; + nos = stack_pointer[-2]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + JUMP_TO_JUMP_TARGET(); } - res = PyStackRef_FromPyObjectSteal(res_o); - ds = dict_st; - ss = sub_st; - _tos_cache2 = ss; - _tos_cache1 = ds; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_CHECK_FUNC_r23: { + case _GUARD_NOS_UNICODE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + nos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_0; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_UNICODE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef container; - _PyStackRef getitem; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - container = _stack_item_0; - PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container)); - if (!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) { + nos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; - _tos_cache0 = container; + _tos_cache0 = nos; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; - PyObject *getitem_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(ht->_spec_cache.getitem); - if (getitem_o == NULL) { + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_UNICODE_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + nos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = container; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - assert(PyFunction_Check(getitem_o)); - uint32_t cached_version = FT_ATOMIC_LOAD_UINT32_RELAXED(ht->_spec_cache.getitem_version); - if (((PyFunctionObject *)getitem_o)->func_version != cached_version) { + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_UNICODE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + nos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; _tos_cache1 = _stack_item_1; - _tos_cache0 = container; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - PyCodeObject *code = (PyCodeObject *)PyFunction_GET_CODE(getitem_o); - assert(code->co_argcount == 2); - if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_UNICODE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + nos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyUnicode_CheckExact(o)) { UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = container; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - getitem = PyStackRef_FromPyObjectNew(getitem_o); - _tos_cache2 = getitem; + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = container; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_INIT_CALL_r01: { + case _GUARD_TOS_UNICODE_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef getitem; - _PyStackRef sub; - _PyStackRef container; - _PyStackRef new_frame; - getitem = stack_pointer[-1]; - sub = stack_pointer[-2]; - container = stack_pointer[-3]; - STAT_INC(BINARY_OP, hit); - _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); - pushed_frame->localsplus[0] = container; - pushed_frame->localsplus[1] = sub; - frame->return_offset = 6u ; - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; + _PyStackRef value; + value = stack_pointer[-1]; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyUnicode_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -3; + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_INIT_CALL_r11: { + case _GUARD_TOS_UNICODE_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef getitem; - _PyStackRef sub; - _PyStackRef container; - _PyStackRef new_frame; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - getitem = _stack_item_0; - sub = stack_pointer[-1]; - container = stack_pointer[-2]; - STAT_INC(BINARY_OP, hit); - _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); - pushed_frame->localsplus[0] = container; - pushed_frame->localsplus[1] = sub; - frame->return_offset = 6u ; - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; + value = _stack_item_0; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyUnicode_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_INIT_CALL_r21: { + case _GUARD_TOS_UNICODE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef getitem; - _PyStackRef sub; - _PyStackRef container; - _PyStackRef new_frame; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - getitem = _stack_item_1; - sub = _stack_item_0; - container = stack_pointer[-1]; - STAT_INC(BINARY_OP, hit); - _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); - pushed_frame->localsplus[0] = container; - pushed_frame->localsplus[1] = sub; - frame->return_offset = 6u ; - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + value = _stack_item_1; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyUnicode_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BINARY_OP_SUBSCR_INIT_CALL_r31: { + case _GUARD_TOS_UNICODE_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef getitem; - _PyStackRef sub; - _PyStackRef container; - _PyStackRef new_frame; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - getitem = _stack_item_2; - sub = _stack_item_1; - container = _stack_item_0; - STAT_INC(BINARY_OP, hit); - _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); - pushed_frame->localsplus[0] = container; - pushed_frame->localsplus[1] = sub; - frame->return_offset = 6u ; - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; - SET_CURRENT_CACHED_VALUES(1); + value = _stack_item_2; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyUnicode_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LIST_APPEND_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_TOS_UNICODE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef v; - _PyStackRef list; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - v = _stack_item_0; - list = stack_pointer[-1 - (oparg-1)]; - int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), - PyStackRef_AsPyObjectSteal(v)); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyUnicode_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SET_ADD_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_TOS_UNICODE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef v; - _PyStackRef set; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - v = _stack_item_0; - set = stack_pointer[-1 - (oparg-1)]; - stack_pointer[0] = v; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _PySet_AddTakeRef((PySetObject *)PyStackRef_AsPyObjectBorrow(set), - PyStackRef_AsPyObjectSteal(v)); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyUnicode_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_SUBSCR_r30: { - CHECK_CURRENT_CACHED_VALUES(3); + case _TO_BOOL_STR_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub; - _PyStackRef container; + _PyStackRef value; + _PyStackRef res; _PyStackRef v; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - sub = _stack_item_2; - container = _stack_item_1; - v = _stack_item_0; - stack_pointer[0] = v; - stack_pointer[1] = container; - stack_pointer[2] = sub; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); - _PyStackRef tmp = sub; - sub = PyStackRef_NULL; - stack_pointer[-1] = sub; - PyStackRef_CLOSE(tmp); - tmp = container; - container = PyStackRef_NULL; - stack_pointer[-2] = container; - PyStackRef_CLOSE(tmp); - tmp = v; - v = PyStackRef_NULL; - stack_pointer[-3] = v; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -3; + value = stack_pointer[-1]; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = value_o == &_Py_STR(empty) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache1 = v; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_SUBSCR_LIST_INT_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _TO_BOOL_STR_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub_st; - _PyStackRef list_st; _PyStackRef value; - _PyStackRef ls; - _PyStackRef ss; + _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - sub_st = _stack_item_2; - list_st = _stack_item_1; value = _stack_item_0; - PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); - PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); - assert(PyLong_CheckExact(sub)); - assert(PyList_CheckExact(list)); - if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = sub_st; - _tos_cache1 = list_st; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; - if (!LOCK_OBJECT(list)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = sub_st; - _tos_cache1 = list_st; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - if (index >= PyList_GET_SIZE(list)) { - UNLOCK_OBJECT(list); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = sub_st; - _tos_cache1 = list_st; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - } - STAT_INC(STORE_SUBSCR, hit); - PyObject *old_value = PyList_GET_ITEM(list, index); - FT_ATOMIC_STORE_PTR_RELEASE(_PyList_ITEMS(list)[index], - PyStackRef_AsPyObjectSteal(value)); - assert(old_value != NULL); - UNLOCK_OBJECT(list); - ls = list_st; - ss = sub_st; - stack_pointer[0] = ls; - stack_pointer[1] = ss; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_DECREF(old_value); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache1 = ss; - _tos_cache0 = ls; - _tos_cache2 = PyStackRef_ZERO_BITS; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = value_o == &_Py_STR(empty) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache1 = v; + _tos_cache0 = res; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_SUBSCR_DICT_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _TO_BOOL_STR_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub; - _PyStackRef dict_st; _PyStackRef value; - _PyStackRef st; + _PyStackRef res; + _PyStackRef v; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + value = _stack_item_1; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = value_o == &_Py_STR(empty) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache2 = v; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _TO_BOOL_STR_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - sub = _stack_item_2; - dict_st = _stack_item_1; - value = _stack_item_0; - PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); - assert(PyDict_CheckExact(dict)); - STAT_INC(STORE_SUBSCR, hit); - stack_pointer[0] = value; - stack_pointer[1] = dict_st; - stack_pointer[2] = sub; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _PyDict_SetItem_Take2((PyDictObject *)dict, - PyStackRef_AsPyObjectSteal(sub), - PyStackRef_AsPyObjectSteal(value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(dict_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - st = dict_st; - _tos_cache0 = st; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + value = _stack_item_2; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = value_o == &_Py_STR(empty) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache3 = v; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _DELETE_SUBSCR_r20: { - CHECK_CURRENT_CACHED_VALUES(2); + case _TO_BOOL_STR_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef sub; - _PyStackRef container; + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - sub = _stack_item_1; - container = _stack_item_0; - stack_pointer[0] = container; - stack_pointer[1] = sub; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), - PyStackRef_AsPyObjectBorrow(sub)); - _PyStackRef tmp = sub; - sub = PyStackRef_NULL; - stack_pointer[-1] = sub; - PyStackRef_CLOSE(tmp); - tmp = container; - container = PyStackRef_NULL; - stack_pointer[-2] = container; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + STAT_INC(TO_BOOL, hit); + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + res = value_o == &_Py_STR(empty) ? PyStackRef_False : PyStackRef_True; + v = value; + _tos_cache4 = v; + _tos_cache3 = res; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _REPLACE_WITH_TRUE_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; + value = stack_pointer[-1]; + res = PyStackRef_True; + v = value; + _tos_cache1 = v; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_INTRINSIC_1_r11: { + case _REPLACE_WITH_TRUE_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); value = _stack_item_0; - assert(oparg <= MAX_INTRINSIC_1); - stack_pointer[0] = value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(value); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_True; + v = value; + _tos_cache1 = v; _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_INTRINSIC_2_r21: { + case _REPLACE_WITH_TRUE_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value1_st; - _PyStackRef value2_st; + _PyStackRef value; _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - value1_st = _stack_item_1; - value2_st = _stack_item_0; - assert(oparg <= MAX_INTRINSIC_2); - PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st); - PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st); - stack_pointer[0] = value2_st; - stack_pointer[1] = value1_st; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); - _PyStackRef tmp = value1_st; - value1_st = PyStackRef_NULL; - stack_pointer[-1] = value1_st; - PyStackRef_CLOSE(tmp); - tmp = value2_st; - value2_st = PyStackRef_NULL; - stack_pointer[-2] = value2_st; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + value = _stack_item_1; + res = PyStackRef_True; + v = value; + _tos_cache2 = v; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _RETURN_VALUE_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _REPLACE_WITH_TRUE_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef retval; + _PyStackRef value; _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - retval = _stack_item_0; - assert(frame->owner != FRAME_OWNED_BY_INTERPRETER); - _PyStackRef temp = PyStackRef_MakeHeapSafe(retval); - _PyFrame_SetStackPointer(frame, stack_pointer); - assert(STACK_LEVEL() == 0); - _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *dying = frame; - frame = tstate->current_frame = dying->previous; - _PyEval_FrameClearAndPop(tstate, dying); - stack_pointer = _PyFrame_GetStackPointer(frame); - LOAD_IP(frame->return_offset); - res = temp; - LLTRACE_RESUME_FRAME(); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + res = PyStackRef_True; + v = value; + _tos_cache3 = v; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GET_AITER_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _REPLACE_WITH_TRUE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef obj; - _PyStackRef iter; + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - obj = _stack_item_0; - unaryfunc getter = NULL; - PyObject *obj_o = PyStackRef_AsPyObjectBorrow(obj); - PyObject *iter_o; - PyTypeObject *type = Py_TYPE(obj_o); - if (type->tp_as_async != NULL) { - getter = type->tp_as_async->am_aiter; - } - if (getter == NULL) { - stack_pointer[0] = obj; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Format(tstate, PyExc_TypeError, - "'async for' requires an object with " - "__aiter__ method, got %.100s", - type->tp_name); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(obj); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - stack_pointer[0] = obj; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - iter_o = (*getter)(obj_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(obj); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (iter_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (Py_TYPE(iter_o)->tp_as_async == NULL || - Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Format(tstate, PyExc_TypeError, - "'async for' received an object from __aiter__ " - "that does not implement __anext__: %.100s", - Py_TYPE(iter_o)->tp_name); - Py_DECREF(iter_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - iter = PyStackRef_FromPyObjectSteal(iter_o); - _tos_cache0 = iter; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + res = PyStackRef_True; + v = value; + _tos_cache4 = v; + _tos_cache3 = res; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GET_ANEXT_r12: { + case _UNARY_INVERT_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef aiter; - _PyStackRef awaitable; + _PyStackRef value; + _PyStackRef res; + _PyStackRef v; _PyStackRef _stack_item_0 = _tos_cache0; - aiter = _stack_item_0; - stack_pointer[0] = aiter; + value = _stack_item_0; + stack_pointer[0] = value; stack_pointer += 1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); + PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (awaitable_o == NULL) { + if (res_o == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - awaitable = PyStackRef_FromPyObjectSteal(awaitable_o); - _tos_cache1 = awaitable; - _tos_cache0 = aiter; + res = PyStackRef_FromPyObjectSteal(res_o); + v = value; + _tos_cache1 = v; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(2); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GET_AWAITABLE_r11: { + case _GUARD_NOS_INT_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!_PyLong_CheckExactAndCompact(left_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_INT_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iterable; - _PyStackRef iter; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - iterable = _stack_item_0; - stack_pointer[0] = iterable; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!_PyLong_CheckExactAndCompact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_0; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(iterable); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (iter_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - iter = PyStackRef_FromPyObjectSteal(iter_o); - _tos_cache0 = iter; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _SEND is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ - - case _SEND_GEN_FRAME_r22: { + case _GUARD_NOS_INT_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef v; - _PyStackRef receiver; - _PyStackRef gen_frame; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - v = _stack_item_1; - receiver = _stack_item_0; - PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(receiver); - if (Py_TYPE(gen) != &PyGen_Type && Py_TYPE(gen) != &PyCoro_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = v; - _tos_cache0 = receiver; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - if (!gen_try_set_executing((PyGenObject *)gen)) { + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!_PyLong_CheckExactAndCompact(left_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = v; - _tos_cache0 = receiver; + _tos_cache1 = _stack_item_1; + _tos_cache0 = left; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - STAT_INC(SEND, hit); - _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; - _PyFrame_StackPush(pushed_frame, PyStackRef_MakeHeapSafe(v)); - gen->gi_exc_state.previous_item = tstate->exc_info; - tstate->exc_info = &gen->gi_exc_state; - assert( 2u + oparg <= UINT16_MAX); - frame->return_offset = (uint16_t)( 2u + oparg); - pushed_frame->previous = frame; - gen_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache1 = gen_frame; - _tos_cache0 = receiver; - _tos_cache2 = PyStackRef_ZERO_BITS; + _tos_cache1 = _stack_item_1; + _tos_cache0 = left; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _YIELD_VALUE_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_NOS_INT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef retval; - _PyStackRef value; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - retval = _stack_item_0; - assert(frame->owner != FRAME_OWNED_BY_INTERPRETER); - frame->instr_ptr++; - PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); - assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); - assert(oparg == 0 || oparg == 1); - _PyStackRef temp = retval; - _PyFrame_SetStackPointer(frame, stack_pointer); - tstate->exc_info = gen->gi_exc_state.previous_item; - gen->gi_exc_state.previous_item = NULL; - _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *gen_frame = frame; - frame = tstate->current_frame = frame->previous; - gen_frame->previous = NULL; - ((_PyThreadStateImpl *)tstate)->generator_return_kind = GENERATOR_YIELD; - FT_ATOMIC_STORE_INT8_RELEASE(gen->gi_frame_state, FRAME_SUSPENDED + oparg); - assert(INLINE_CACHE_ENTRIES_SEND == INLINE_CACHE_ENTRIES_FOR_ITER); - #if TIER_ONE - assert(frame->instr_ptr->op.code == INSTRUMENTED_LINE || - frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); - #endif - stack_pointer = _PyFrame_GetStackPointer(frame); - LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); - value = PyStackRef_MakeHeapSafe(temp); - LLTRACE_RESUME_FRAME(); - _tos_cache0 = value; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!_PyLong_CheckExactAndCompact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = left; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = left; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_EXCEPT_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_NOS_INT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef exc_value; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - exc_value = _stack_item_0; - _PyErr_StackItem *exc_info = tstate->exc_info; - stack_pointer[0] = exc_value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_XSETREF(exc_info->exc_value, - PyStackRef_IsNone(exc_value) - ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!_PyLong_CheckExactAndCompact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = left; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = left; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_COMMON_CONSTANT_r01: { + case _GUARD_NOS_INT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + left = _stack_item_3; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!_PyLong_CheckExactAndCompact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = left; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = left; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_INT_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; - oparg = CURRENT_OPARG(); - assert(oparg < NUM_COMMON_CONSTANTS); - value = PyStackRef_FromPyObjectNew(tstate->interp->common_consts[oparg]); + value = stack_pointer[-1]; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!_PyLong_CheckExactAndCompact(value_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_COMMON_CONSTANT_r12: { + case _GUARD_TOS_INT_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - assert(oparg < NUM_COMMON_CONSTANTS); - value = PyStackRef_FromPyObjectNew(tstate->interp->common_consts[oparg]); + value = _stack_item_0; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!_PyLong_CheckExactAndCompact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_INT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + value = _stack_item_1; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!_PyLong_CheckExactAndCompact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_COMMON_CONSTANT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_TOS_INT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - assert(oparg < NUM_COMMON_CONSTANTS); - value = PyStackRef_FromPyObjectNew(tstate->interp->common_consts[oparg]); + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!_PyLong_CheckExactAndCompact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } _tos_cache2 = value; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_BUILD_CLASS_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_TOS_INT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bc; - int err; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *bc_o = _PyMapping_GetOptionalItem2(BUILTINS(), &_Py_ID(__build_class__), &err); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (bc_o == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetString(tstate, PyExc_NameError, - "__build_class__ not found"); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!_PyLong_CheckExactAndCompact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - bc = PyStackRef_FromPyObjectSteal(bc_o); - _tos_cache0 = bc; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_NAME_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_TOS_INT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef v; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - v = _stack_item_0; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - PyObject *ns = LOCALS(); - int err; - if (ns == NULL) { - stack_pointer[0] = v; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Format(tstate, PyExc_SystemError, - "no locals found when storing %R", name); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(v); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (PyDict_CheckExact(ns)) { - stack_pointer[0] = v; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else { - stack_pointer[0] = v; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(v); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!_PyLong_CheckExactAndCompact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _DELETE_NAME_r00: { + case _GUARD_NOS_OVERFLOWED_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - oparg = CURRENT_OPARG(); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - PyObject *ns = LOCALS(); - int err; - if (ns == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Format(tstate, PyExc_SystemError, - "no locals when deleting %R", name); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - err = PyObject_DelItem(ns, name); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, - NAME_ERROR_MSG, - name); - stack_pointer = _PyFrame_GetStackPointer(frame); + _PyStackRef left; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + assert(Py_TYPE(left_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)left_o)) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNPACK_SEQUENCE_r10: { + case _GUARD_NOS_OVERFLOWED_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef seq; - _PyStackRef *top; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - seq = _stack_item_0; - top = &stack_pointer[oparg]; - PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq); - _PyFrame_SetStackPointer(frame, stack_pointer); - int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top); - Py_DECREF(seq_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res == 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + assert(Py_TYPE(left_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += oparg; + _tos_cache1 = _stack_item_0; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNPACK_SEQUENCE_TWO_TUPLE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_NOS_OVERFLOWED_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef seq; - _PyStackRef val1; - _PyStackRef val0; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - seq = _stack_item_0; - assert(oparg == 2); - PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); - assert(PyTuple_CheckExact(seq_o)); - if (PyTuple_GET_SIZE(seq_o) != 2) { + _PyStackRef _stack_item_1 = _tos_cache1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + assert(Py_TYPE(left_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)left_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = seq; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache1 = _stack_item_1; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - STAT_INC(UNPACK_SEQUENCE, hit); - val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0)); - val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1)); - stack_pointer[0] = val1; - stack_pointer[1] = val0; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(seq); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache1 = val0; - _tos_cache0 = val1; - _tos_cache2 = PyStackRef_ZERO_BITS; + _tos_cache1 = _stack_item_1; + _tos_cache0 = left; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNPACK_SEQUENCE_TUPLE_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_NOS_OVERFLOWED_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef seq; - _PyStackRef *values; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - seq = _stack_item_0; - values = &stack_pointer[0]; - PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); - assert(PyTuple_CheckExact(seq_o)); - if (PyTuple_GET_SIZE(seq_o) != oparg) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + assert(Py_TYPE(left_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)left_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = seq; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_2; + _tos_cache1 = left; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - STAT_INC(UNPACK_SEQUENCE, hit); - PyObject **items = _PyTuple_ITEMS(seq_o); - for (int i = oparg; --i >= 0; ) { - *values++ = PyStackRef_FromPyObjectNew(items[i]); - } - stack_pointer += oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(seq); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = _stack_item_2; + _tos_cache1 = left; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNPACK_SEQUENCE_LIST_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_NOS_OVERFLOWED_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef seq; - _PyStackRef *values; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - seq = _stack_item_0; - values = &stack_pointer[0]; - PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); - assert(PyList_CheckExact(seq_o)); - if (!LOCK_OBJECT(seq_o)) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + assert(Py_TYPE(left_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)left_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = seq; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache3 = _stack_item_3; + _tos_cache2 = left; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - if (PyList_GET_SIZE(seq_o) != oparg) { - UNLOCK_OBJECT(seq_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = seq; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + _tos_cache3 = _stack_item_3; + _tos_cache2 = left; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_OVERFLOWED_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + left = _stack_item_3; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + assert(Py_TYPE(left_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = left; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - STAT_INC(UNPACK_SEQUENCE, hit); - PyObject **items = _PyList_ITEMS(seq_o); - for (int i = oparg; --i >= 0; ) { - *values++ = PyStackRef_FromPyObjectNew(items[i]); + _tos_cache4 = _stack_item_4; + _tos_cache3 = left; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_OVERFLOWED_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + value = stack_pointer[-1]; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(Py_TYPE(value_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)value_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - UNLOCK_OBJECT(seq_o); - stack_pointer += oparg; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(seq); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _UNPACK_EX_r10: { + case _GUARD_TOS_OVERFLOWED_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef seq; - _PyStackRef *top; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - seq = _stack_item_0; - top = &stack_pointer[1 + (oparg & 0xFF) + (oparg >> 8)]; - PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq); - _PyFrame_SetStackPointer(frame, stack_pointer); - int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg & 0xFF, oparg >> 8, top); - Py_DECREF(seq_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res == 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + value = _stack_item_0; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(Py_TYPE(value_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_ATTR_r20: { + case _GUARD_TOS_OVERFLOWED_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef v; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - owner = _stack_item_1; - v = _stack_item_0; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer[0] = v; - stack_pointer[1] = owner; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), - name, PyStackRef_AsPyObjectBorrow(v)); - _PyStackRef tmp = owner; - owner = PyStackRef_NULL; - stack_pointer[-1] = owner; - PyStackRef_CLOSE(tmp); - tmp = v; - v = PyStackRef_NULL; - stack_pointer[-2] = v; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + value = _stack_item_1; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(Py_TYPE(value_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _DELETE_ATTR_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_TOS_OVERFLOWED_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - owner = _stack_item_0; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer[0] = owner; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(owner); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(Py_TYPE(value_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_GLOBAL_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_TOS_OVERFLOWED_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef v; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - v = _stack_item_0; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer[0] = v; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(v); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(Py_TYPE(value_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _DELETE_GLOBAL_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_TOS_OVERFLOWED_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - oparg = CURRENT_OPARG(); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyDict_Pop(GLOBALS(), name, NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (err == 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, - NAME_ERROR_MSG, name); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + assert(Py_TYPE(value_o) == &PyLong_Type); + if (!_PyLong_IsCompact((PyLongObject *)value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_LOCALS_r01: { + case _BINARY_OP_MULTIPLY_INT_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef locals; - PyObject *l = LOCALS(); - if (l == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetString(tstate, PyExc_SystemError, - "no locals found"); - stack_pointer = _PyFrame_GetStackPointer(frame); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + JUMP_TO_JUMP_TARGET(); } - locals = PyStackRef_FromPyObjectNew(l); - _tos_cache0 = locals; - SET_CURRENT_CACHED_VALUES(1); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_LOCALS_r12: { + case _BINARY_OP_MULTIPLY_INT_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef locals; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - PyObject *l = LOCALS(); - if (l == NULL) { - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetString(tstate, PyExc_SystemError, - "no locals found"); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = right; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); } - locals = PyStackRef_FromPyObjectNew(l); - _tos_cache1 = locals; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_LOCALS_r23: { + case _BINARY_OP_MULTIPLY_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef locals; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - PyObject *l = LOCALS(); - if (l == NULL) { - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetString(tstate, PyExc_SystemError, - "no locals found"); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = right; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); } - locals = PyStackRef_FromPyObjectNew(l); - _tos_cache2 = locals; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _LOAD_FROM_DICT_OR_GLOBALS is not a viable micro-op for tier 2 because it has both popping and not-popping errors */ - - case _LOAD_NAME_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _BINARY_OP_MULTIPLY_INT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef v; - oparg = CURRENT_OPARG(); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *v_o = _PyEval_LoadName(tstate, frame, name); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (v_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (PyLazyImport_CheckExact(v_o)) { - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (l_v == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_DECREF(v_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyDict_SetItem(GLOBALS(), name, l_v); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_DECREF(v_o); - Py_DECREF(l_v); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_SETREF(v_o, l_v); - stack_pointer = _PyFrame_GetStackPointer(frame); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + right = _stack_item_2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = right; + _tos_cache1 = left; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } - v = PyStackRef_FromPyObjectSteal(v_o); - _tos_cache0 = v; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_GLOBAL_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _BINARY_OP_MULTIPLY_INT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *res; - oparg = CURRENT_OPARG(); - res = &stack_pointer[0]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(*res)) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + right = _stack_item_3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = right; + _tos_cache2 = left; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _PUSH_NULL_CONDITIONAL_r00: { + case _BINARY_OP_ADD_INT_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *null; - oparg = CURRENT_OPARG(); - null = &stack_pointer[0]; - if (oparg & 1) { - null[0] = PyStackRef_NULL; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += (oparg & 1); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_GLOBALS_VERSION_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _BINARY_OP_ADD_INT_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); - PyDictObject *dict = (PyDictObject *)GLOBALS(); - if (!PyDict_CheckExact(dict)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache0 = right; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - assert(keys->dk_kind == DICT_KEYS_UNICODE); - SET_CURRENT_CACHED_VALUES(0); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_GLOBALS_VERSION_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _BINARY_OP_ADD_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); - PyDictObject *dict = (PyDictObject *)GLOBALS(); - if (!PyDict_CheckExact(dict)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache1 = right; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - assert(keys->dk_kind == DICT_KEYS_UNICODE); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_GLOBALS_VERSION_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _BINARY_OP_ADD_INT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); - PyDictObject *dict = (PyDictObject *)GLOBALS(); - if (!PyDict_CheckExact(dict)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + _PyStackRef _stack_item_2 = _tos_cache2; + right = _stack_item_2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; + _tos_cache2 = right; + _tos_cache1 = left; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - assert(keys->dk_kind == DICT_KEYS_UNICODE); - _tos_cache1 = _stack_item_1; + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_GLOBALS_VERSION_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _BINARY_OP_ADD_INT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); - PyDictObject *dict = (PyDictObject *)GLOBALS(); - if (!PyDict_CheckExact(dict)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + _PyStackRef _stack_item_3 = _tos_cache3; + right = _stack_item_3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; + _tos_cache3 = right; + _tos_cache2 = left; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - assert(keys->dk_kind == DICT_KEYS_UNICODE); - _tos_cache2 = _stack_item_2; + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_GLOBAL_MODULE_r01: { + case _BINARY_OP_SUBTRACT_INT_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; _PyStackRef res; - uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); - uint16_t index = (uint16_t)CURRENT_OPERAND1_16(); - PyDictObject *dict = (PyDictObject *)GLOBALS(); - if (!PyDict_CheckExact(dict)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - assert(keys->dk_kind == DICT_KEYS_UNICODE); - PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(keys); - assert(index < DK_SIZE(keys)); - PyObject *res_o = FT_ATOMIC_LOAD_PTR_RELAXED(entries[index].me_value); - if (res_o == NULL) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - #if Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(&entries[index].me_value, res_o, &res); - if (!increfed) { + _PyStackRef l; + _PyStackRef r; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - #else - res = PyStackRef_FromPyObjectNew(res_o); - #endif - STAT_INC(LOAD_GLOBAL, hit); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_GLOBAL_BUILTINS_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _BINARY_OP_SUBTRACT_INT_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; _PyStackRef res; - uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); - uint16_t index = (uint16_t)CURRENT_OPERAND1_16(); - PyDictObject *dict = (PyDictObject *)BUILTINS(); - if (!PyDict_CheckExact(dict)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - assert(keys->dk_kind == DICT_KEYS_UNICODE); - PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(keys); - PyObject *res_o = FT_ATOMIC_LOAD_PTR_RELAXED(entries[index].me_value); - if (res_o == NULL) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - #if Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(&entries[index].me_value, res_o, &res); - if (!increfed) { + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache0 = right; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - #else - res = PyStackRef_FromPyObjectNew(res_o); - #endif - STAT_INC(LOAD_GLOBAL, hit); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _DELETE_FAST_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _BINARY_OP_SUBTRACT_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - oparg = CURRENT_OPARG(); - _PyStackRef v = GETLOCAL(oparg); - if (PyStackRef_IsNull(v)) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, - UNBOUNDLOCAL_ERROR_MSG, - PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) - ); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = PyStackRef_NULL; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_XCLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _MAKE_CELL_r00: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - oparg = CURRENT_OPARG(); - PyObject *initial = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - PyObject *cell = PyCell_New(initial); - if (cell == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = right; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); } - _PyStackRef tmp = GETLOCAL(oparg); - GETLOCAL(oparg) = PyStackRef_FromPyObjectSteal(cell); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_XCLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _DELETE_DEREF_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _BINARY_OP_SUBTRACT_INT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - oparg = CURRENT_OPARG(); - PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); - if (oldobj == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + right = _stack_item_2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = right; + _tos_cache1 = left; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_DECREF(oldobj); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_FROM_DICT_OR_DEREF_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _BINARY_OP_SUBTRACT_INT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef class_dict_st; - _PyStackRef value; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - class_dict_st = _stack_item_0; - PyObject *name; - PyObject *class_dict = PyStackRef_AsPyObjectBorrow(class_dict_st); - assert(class_dict); - assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); - name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); - int err; - stack_pointer[0] = class_dict_st; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject* value_o = _PyMapping_GetOptionalItem2(class_dict, name, &err); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (!value_o) { - PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - value_o = PyCell_GetRef(cell); - if (value_o == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + right = _stack_item_3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyLong_CheckExact(left_o)); + assert(PyLong_CheckExact(right_o)); + assert(_PyLong_BothAreCompact((PyLongObject *)left_o, (PyLongObject *)right_o)); + STAT_INC(BINARY_OP, hit); + res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); + if (PyStackRef_IsNull(res)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = right; + _tos_cache2 = left; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(class_dict_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - value = PyStackRef_FromPyObjectSteal(value_o); - _tos_cache0 = value; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_DEREF_r01: { + case _GUARD_NOS_FLOAT_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - oparg = CURRENT_OPARG(); - PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - _PyFrame_SetStackPointer(frame, stack_pointer); - value = _PyCell_GetStackRef(cell); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(value)) { - stack_pointer[0] = value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); + _PyStackRef left; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!PyFloat_CheckExact(left_o)) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = value; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_DEREF_r10: { + case _GUARD_NOS_FLOAT_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef v; + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - v = _stack_item_0; - PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - stack_pointer[0] = v; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!PyFloat_CheckExact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_0; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_FREE_VARS_r00: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - oparg = CURRENT_OPARG(); - PyCodeObject *co = _PyFrame_GetCode(frame); - assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); - PyObject *closure = func->func_closure; - assert(oparg == co->co_nfreevars); - int offset = co->co_nlocalsplus - oparg; - for (int i = 0; i < oparg; ++i) { - PyObject *o = PyTuple_GET_ITEM(closure, i); - frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); - } - SET_CURRENT_CACHED_VALUES(0); + case _GUARD_NOS_FLOAT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _COPY_FREE_VARS_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + _PyStackRef left; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!PyFloat_CheckExact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_FLOAT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - PyCodeObject *co = _PyFrame_GetCode(frame); - assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); - PyObject *closure = func->func_closure; - assert(oparg == co->co_nfreevars); - int offset = co->co_nlocalsplus - oparg; - for (int i = 0; i < oparg; ++i) { - PyObject *o = PyTuple_GET_ITEM(closure, i); - frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!PyFloat_CheckExact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = left; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } + _tos_cache2 = _stack_item_2; + _tos_cache1 = left; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_FREE_VARS_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_NOS_FLOAT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - PyCodeObject *co = _PyFrame_GetCode(frame); - assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); - PyObject *closure = func->func_closure; - assert(oparg == co->co_nfreevars); - int offset = co->co_nlocalsplus - oparg; - for (int i = 0; i < oparg; ++i) { - PyObject *o = PyTuple_GET_ITEM(closure, i); - frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!PyFloat_CheckExact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = left; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; + _tos_cache2 = left; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_FREE_VARS_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_NOS_FLOAT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - PyCodeObject *co = _PyFrame_GetCode(frame); - assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); - PyObject *closure = func->func_closure; - assert(oparg == co->co_nfreevars); - int offset = co->co_nlocalsplus - oparg; - for (int i = 0; i < oparg; ++i) { - PyObject *o = PyTuple_GET_ITEM(closure, i); - frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + left = _stack_item_3; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + if (!PyFloat_CheckExact(left_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = left; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } + _tos_cache4 = _stack_item_4; + _tos_cache3 = left; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BUILD_STRING_r01: { + case _GUARD_TOS_FLOAT_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *pieces; - _PyStackRef str; - oparg = CURRENT_OPARG(); - pieces = &stack_pointer[-oparg]; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *str_o = _Py_BuildString_StackRefSteal(pieces, oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (str_o == NULL) { - stack_pointer += -oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef value; + value = stack_pointer[-1]; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyFloat_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + JUMP_TO_JUMP_TARGET(); } - str = PyStackRef_FromPyObjectSteal(str_o); - _tos_cache0 = str; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -oparg; + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BUILD_INTERPOLATION_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_TOS_FLOAT_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *format; - _PyStackRef str; _PyStackRef value; - _PyStackRef interpolation; - oparg = CURRENT_OPARG(); - format = &stack_pointer[-(oparg & 1)]; - str = stack_pointer[-1 - (oparg & 1)]; - value = stack_pointer[-2 - (oparg & 1)]; + _PyStackRef _stack_item_0 = _tos_cache0; + value = _stack_item_0; PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - PyObject *str_o = PyStackRef_AsPyObjectBorrow(str); - int conversion = oparg >> 2; - PyObject *format_o; - if (oparg & 1) { - format_o = PyStackRef_AsPyObjectBorrow(format[0]); - } - else { - format_o = &_Py_STR(empty); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *interpolation_o = _PyInterpolation_Build(value_o, str_o, conversion, format_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (oparg & 1) { - stack_pointer += -(oparg & 1); - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(format[0]); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else { - stack_pointer += -(oparg & 1); - } - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(str); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(value); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (interpolation_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + if (!PyFloat_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); } - interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); - _tos_cache0 = interpolation; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BUILD_TEMPLATE_r21: { + case _GUARD_TOS_FLOAT_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef interpolations; - _PyStackRef strings; - _PyStackRef template; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - interpolations = _stack_item_1; - strings = _stack_item_0; - PyObject *strings_o = PyStackRef_AsPyObjectBorrow(strings); - PyObject *interpolations_o = PyStackRef_AsPyObjectBorrow(interpolations); - stack_pointer[0] = strings; - stack_pointer[1] = interpolations; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(interpolations); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(strings); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (template_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + value = _stack_item_1; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyFloat_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); } - template = PyStackRef_FromPyObjectSteal(template_o); - _tos_cache0 = template; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BUILD_TUPLE_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *values; - _PyStackRef tup; - oparg = CURRENT_OPARG(); - values = &stack_pointer[-oparg]; - PyObject *tup_o = _PyTuple_FromStackRefStealOnSuccess(values, oparg); - if (tup_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - tup = PyStackRef_FromPyObjectStealMortal(tup_o); - _tos_cache0 = tup; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + case _GUARD_TOS_FLOAT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _BUILD_LIST_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *values; - _PyStackRef list; - oparg = CURRENT_OPARG(); - values = &stack_pointer[-oparg]; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *list_o = _PyList_FromStackRefStealOnSuccess(values, oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (list_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + value = _stack_item_2; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyFloat_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } - list = PyStackRef_FromPyObjectStealMortal(list_o); - _tos_cache0 = list; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LIST_EXTEND_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_TOS_FLOAT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iterable_st; - _PyStackRef list_st; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - iterable_st = _stack_item_0; - list_st = stack_pointer[-1 - (oparg-1)]; - PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); - PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); - stack_pointer[0] = iterable_st; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (none_val == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (matches && - (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) - { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Clear(tstate); - _PyErr_Format(tstate, PyExc_TypeError, - "Value after * must be an iterable, not %.200s", - Py_TYPE(iterable)->tp_name); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(iterable_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + value = _stack_item_3; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyFloat_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - assert(Py_IsNone(none_val)); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(iterable_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SET_UPDATE_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_TOS_FLOAT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iterable; - _PyStackRef set; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - iterable = _stack_item_0; - set = stack_pointer[-1 - (oparg-1)]; - stack_pointer[0] = iterable; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), - PyStackRef_AsPyObjectBorrow(iterable)); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(iterable); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + value = _stack_item_4; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyFloat_CheckExact(value_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BUILD_SET_r01: { + case _BINARY_OP_MULTIPLY_FLOAT_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *values; - _PyStackRef set; - oparg = CURRENT_OPARG(); - values = &stack_pointer[-oparg]; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *set_o = PySet_New(NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (set_o == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp; - for (int _i = oparg; --_i >= 0;) { - tmp = values[_i]; - values[_i] = PyStackRef_NULL; - PyStackRef_CLOSE(tmp); - } - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - int err = 0; - for (Py_ssize_t i = 0; i < oparg; i++) { - _PyStackRef value = values[i]; - values[i] = PyStackRef_NULL; - if (err == 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else { - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(value); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - } - if (err) { - stack_pointer += -oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_DECREF(set_o); - stack_pointer = _PyFrame_GetStackPointer(frame); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval * + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - set = PyStackRef_FromPyObjectStealMortal(set_o); - _tos_cache0 = set; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -oparg; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BUILD_MAP_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _BINARY_OP_MULTIPLY_FLOAT_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *values; - _PyStackRef map; - oparg = CURRENT_OPARG(); - values = &stack_pointer[-oparg*2]; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *map_o = _Py_BuildMap_StackRefSteal(values, oparg); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (map_o == NULL) { - stack_pointer += -oparg*2; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval * + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = right; + stack_pointer += 1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - map = PyStackRef_FromPyObjectStealMortal(map_o); - _tos_cache0 = map; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -oparg*2; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SETUP_ANNOTATIONS_r00: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - if (LOCALS() == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Format(tstate, PyExc_SystemError, - "no locals found when setting up annotations"); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - int err; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject* ann_dict = _PyMapping_GetOptionalItem2(LOCALS(), &_Py_ID(__annotations__), &err); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (ann_dict == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - ann_dict = PyDict_New(); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (ann_dict == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), - ann_dict); - Py_DECREF(ann_dict); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - } - else { - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_DECREF(ann_dict); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _DICT_UPDATE_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _BINARY_OP_MULTIPLY_FLOAT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef update; - _PyStackRef dict; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - update = _stack_item_0; - dict = stack_pointer[-1 - (oparg - 1)]; - PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); - stack_pointer[0] = update; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = PyDict_Update(dict_o, update_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (matches) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Format(tstate, PyExc_TypeError, - "'%.200s' object is not a mapping", - Py_TYPE(update_o)->tp_name); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - stack_pointer += -1; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval * + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(update); - stack_pointer = _PyFrame_GetStackPointer(frame); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(update); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _DICT_MERGE_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _BINARY_OP_MULTIPLY_FLOAT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef update; - _PyStackRef dict; - _PyStackRef callable; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - update = _stack_item_0; - dict = stack_pointer[-1 - (oparg - 1)]; - callable = stack_pointer[-4 - (oparg - 1)]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); - stack_pointer[0] = update; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _PyDict_MergeEx(dict_o, update_o, 2); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_FormatKwargsError(tstate, callable_o, update_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + right = _stack_item_2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval * + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = left; + stack_pointer[2] = right; + stack_pointer += 3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(update); - stack_pointer = _PyFrame_GetStackPointer(frame); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(update); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MAP_ADD_r20: { - CHECK_CURRENT_CACHED_VALUES(2); + case _BINARY_OP_MULTIPLY_FLOAT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - _PyStackRef key; - _PyStackRef dict_st; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - value = _stack_item_1; - key = _stack_item_0; - dict_st = stack_pointer[-1 - (oparg - 1)]; - PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); - assert(PyDict_CheckExact(dict)); - stack_pointer[0] = key; - stack_pointer[1] = value; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _PyDict_SetItem_Take2( - (PyDictObject *)dict, - PyStackRef_AsPyObjectSteal(key), - PyStackRef_AsPyObjectSteal(value) - ); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) { - stack_pointer += -2; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + right = _stack_item_3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval * + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = left; + stack_pointer[3] = right; + stack_pointer += 4; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SUPER_ATTR_ATTR_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _BINARY_OP_ADD_FLOAT_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self_st; - _PyStackRef class_st; - _PyStackRef global_super_st; - _PyStackRef attr_st; - _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval + + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_FLOAT_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval + + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = right; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_FLOAT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval + + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_FLOAT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + right = _stack_item_2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval + + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = left; + stack_pointer[2] = right; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_FLOAT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + right = _stack_item_3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval + + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = left; + stack_pointer[3] = right; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBTRACT_FLOAT_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval - + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBTRACT_FLOAT_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval - + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = right; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBTRACT_FLOAT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval - + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBTRACT_FLOAT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + right = _stack_item_2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval - + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = left; + stack_pointer[2] = right; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBTRACT_FLOAT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + right = _stack_item_3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyFloat_CheckExact(left_o)); + assert(PyFloat_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + double dres = + ((PyFloatObject *)left_o)->ob_fval - + ((PyFloatObject *)right_o)->ob_fval; + res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres)); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = left; + stack_pointer[3] = right; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_UNICODE_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyUnicode_CheckExact(left_o)); + assert(PyUnicode_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + PyObject *res_o = PyUnicode_Concat(left_o, right_o); + res = PyStackRef_FromPyObjectSteal(res_o); + if (PyStackRef_IsNull(res)) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_UNICODE_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyUnicode_CheckExact(left_o)); + assert(PyUnicode_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + PyObject *res_o = PyUnicode_Concat(left_o, right_o); + res = PyStackRef_FromPyObjectSteal(res_o); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = right; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_UNICODE_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyUnicode_CheckExact(left_o)); + assert(PyUnicode_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + PyObject *res_o = PyUnicode_Concat(left_o, right_o); + res = PyStackRef_FromPyObjectSteal(res_o); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_UNICODE_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + right = _stack_item_2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyUnicode_CheckExact(left_o)); + assert(PyUnicode_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + PyObject *res_o = PyUnicode_Concat(left_o, right_o); + res = PyStackRef_FromPyObjectSteal(res_o); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = left; + stack_pointer[2] = right; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_ADD_UNICODE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + right = _stack_item_3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyUnicode_CheckExact(left_o)); + assert(PyUnicode_CheckExact(right_o)); + STAT_INC(BINARY_OP, hit); + PyObject *res_o = PyUnicode_Concat(left_o, right_o); + res = PyStackRef_FromPyObjectSteal(res_o); + if (PyStackRef_IsNull(res)) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = left; + stack_pointer[3] = right; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_INPLACE_ADD_UNICODE_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + assert(PyUnicode_CheckExact(left_o)); + assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(right))); + int next_oparg; + #if TIER_ONE + assert(next_instr->op.code == STORE_FAST); + next_oparg = next_instr->op.arg; + #else + next_oparg = (int)CURRENT_OPERAND0_16(); + #endif + _PyStackRef *target_local = &GETLOCAL(next_oparg); + assert(PyUnicode_CheckExact(left_o)); + if (PyStackRef_AsPyObjectBorrow(*target_local) != left_o) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = right; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(BINARY_OP, hit); + assert(Py_REFCNT(left_o) >= 2 || !PyStackRef_IsHeapSafe(left)); + PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local); + PyObject *right_o = PyStackRef_AsPyObjectSteal(right); + PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyUnicode_Append(&temp, right_o); + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + stack_pointer = _PyFrame_GetStackPointer(frame); + *target_local = PyStackRef_NULL; + if (temp == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(temp); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BINARY_OP_EXTEND_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + _PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr*)descr; + assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5); + assert(d && d->guard); + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int res = d->guard(left_o, right_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (!res) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = right; + _tos_cache0 = left; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = right; + _tos_cache0 = left; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_EXTEND_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5); + _PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr*)descr; + STAT_INC(BINARY_OP, hit); + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = d->action(left_o, right_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_SLICE_r31: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef stop; + _PyStackRef start; + _PyStackRef container; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + stop = _stack_item_2; + start = _stack_item_1; + container = _stack_item_0; + PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); + PyObject *start_o = PyStackRef_AsPyObjectBorrow(start); + PyObject *stop_o = PyStackRef_AsPyObjectBorrow(stop); + PyObject *res_o; + if (PyList_CheckExact(container_o)) { + stack_pointer[0] = container; + stack_pointer[1] = start; + stack_pointer[2] = stop; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = _PyList_BinarySlice(container_o, start_o, stop_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else if (PyTuple_CheckExact(container_o)) { + stack_pointer[0] = container; + stack_pointer[1] = start; + stack_pointer[2] = stop; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = _PyTuple_BinarySlice(container_o, start_o, stop_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else if (PyUnicode_CheckExact(container_o)) { + stack_pointer[0] = container; + stack_pointer[1] = start; + stack_pointer[2] = stop; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = _PyUnicode_BinarySlice(container_o, start_o, stop_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else { + PyObject *slice = PySlice_New(start_o, stop_o, NULL); + if (slice == NULL) { + res_o = NULL; + } + else { + stack_pointer[0] = container; + stack_pointer[1] = start; + stack_pointer[2] = stop; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = PyObject_GetItem(container_o, slice); + Py_DECREF(slice); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -3; + } + stack_pointer += 3; + } + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp = stop; + stop = PyStackRef_NULL; + stack_pointer[-3] = container; + stack_pointer[-2] = start; + stack_pointer[-1] = stop; + PyStackRef_CLOSE(tmp); + tmp = start; + start = PyStackRef_NULL; + stack_pointer[-2] = start; + PyStackRef_CLOSE(tmp); + tmp = container; + container = PyStackRef_NULL; + stack_pointer[-3] = container; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_SLICE_r40: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef stop; + _PyStackRef start; + _PyStackRef container; + _PyStackRef v; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + stop = _stack_item_3; + start = _stack_item_2; + container = _stack_item_1; + v = _stack_item_0; + stack_pointer[0] = v; + stack_pointer[1] = container; + stack_pointer[2] = start; + stack_pointer[3] = stop; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), + PyStackRef_AsPyObjectSteal(stop)); + stack_pointer = _PyFrame_GetStackPointer(frame); + int err; + if (slice == NULL) { + err = 1; + } + else { + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); + Py_DECREF(slice); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += 2; + } + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp = container; + container = PyStackRef_NULL; + stack_pointer[-3] = container; + PyStackRef_CLOSE(tmp); + tmp = v; + v = PyStackRef_NULL; + stack_pointer[-4] = v; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_LIST_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef list_st; + _PyStackRef res; + _PyStackRef ls; + _PyStackRef ss; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + sub_st = _stack_item_1; + list_st = _stack_item_0; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); + assert(PyLong_CheckExact(sub)); + assert(PyList_CheckExact(list)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = list_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + #ifdef Py_GIL_DISABLED + stack_pointer[0] = list_st; + stack_pointer[1] = sub_st; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyList_GetItemRef((PyListObject*)list, index); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = list_st; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(BINARY_OP, hit); + res = PyStackRef_FromPyObjectSteal(res_o); + #else + if (index >= PyList_GET_SIZE(list)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = list_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(BINARY_OP, hit); + PyObject *res_o = PyList_GET_ITEM(list, index); + assert(res_o != NULL); + res = PyStackRef_FromPyObjectNew(res_o); + stack_pointer += 2; + #endif + STAT_INC(BINARY_OP, hit); + ls = list_st; + ss = sub_st; + _tos_cache2 = ss; + _tos_cache1 = ls; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_LIST_SLICE_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef list_st; + _PyStackRef res; + _PyStackRef ls; + _PyStackRef ss; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + sub_st = _stack_item_1; + list_st = _stack_item_0; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); + assert(PySlice_Check(sub)); + assert(PyList_CheckExact(list)); + stack_pointer[0] = list_st; + stack_pointer[1] = sub_st; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyList_SliceSubscript(list, sub); + stack_pointer = _PyFrame_GetStackPointer(frame); + STAT_INC(BINARY_OP, hit); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + ls = list_st; + ss = sub_st; + _tos_cache2 = ss; + _tos_cache1 = ls; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_STR_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef str_st; + _PyStackRef res; + _PyStackRef s; + _PyStackRef i; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + sub_st = _stack_item_1; + str_st = _stack_item_0; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *str = PyStackRef_AsPyObjectBorrow(str_st); + assert(PyLong_CheckExact(sub)); + assert(PyUnicode_CheckExact(str)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject*)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = str_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (PyUnicode_GET_LENGTH(str) <= index) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = str_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + uint8_t c = PyUnicode_1BYTE_DATA(str)[index]; + assert(c < 128); + STAT_INC(BINARY_OP, hit); + PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; + s = str_st; + i = sub_st; + res = PyStackRef_FromPyObjectBorrow(res_o); + _tos_cache2 = i; + _tos_cache1 = s; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_USTR_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef str_st; + _PyStackRef res; + _PyStackRef s; + _PyStackRef i; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + sub_st = _stack_item_1; + str_st = _stack_item_0; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *str = PyStackRef_AsPyObjectBorrow(str_st); + assert(PyLong_CheckExact(sub)); + assert(PyUnicode_CheckExact(str)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject*)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = str_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (PyUnicode_GET_LENGTH(str) <= index) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = str_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + Py_UCS4 c = PyUnicode_READ_CHAR(str, index); + if (Py_ARRAY_LENGTH(_Py_SINGLETON(strings).ascii) <= c) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = str_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(BINARY_OP, hit); + PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; + s = str_st; + i = sub_st; + res = PyStackRef_FromPyObjectBorrow(res_o); + _tos_cache2 = i; + _tos_cache1 = s; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_TUPLE_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + nos = stack_pointer[-2]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_TUPLE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + nos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_0; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_TUPLE_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + nos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_TUPLE_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + nos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_TUPLE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + nos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_TUPLE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + nos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_TUPLE_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + tos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_TUPLE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + tos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_TUPLE_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + tos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_TUPLE_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + tos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_TUPLE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_TUPLE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyTuple_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + sub_st = stack_pointer[-1]; + tuple_st = stack_pointer[-2]; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (index >= PyTuple_GET_SIZE(tuple)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = sub_st; + _tos_cache0 = tuple_st; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef _stack_item_0 = _tos_cache0; + sub_st = _stack_item_0; + tuple_st = stack_pointer[-1]; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = sub_st; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (index >= PyTuple_GET_SIZE(tuple)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = sub_st; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = sub_st; + _tos_cache0 = tuple_st; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + sub_st = _stack_item_1; + tuple_st = _stack_item_0; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = tuple_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (index >= PyTuple_GET_SIZE(tuple)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = sub_st; + _tos_cache0 = tuple_st; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = sub_st; + _tos_cache0 = tuple_st; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + sub_st = _stack_item_2; + tuple_st = _stack_item_1; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = sub_st; + _tos_cache1 = tuple_st; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (index >= PyTuple_GET_SIZE(tuple)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = sub_st; + _tos_cache1 = tuple_st; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = sub_st; + _tos_cache1 = tuple_st; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + sub_st = _stack_item_3; + tuple_st = _stack_item_2; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = sub_st; + _tos_cache2 = tuple_st; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (index >= PyTuple_GET_SIZE(tuple)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = sub_st; + _tos_cache2 = tuple_st; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = sub_st; + _tos_cache2 = tuple_st; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BINARY_OP_SUBSCR_TUPLE_INT_BOUNDS_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + sub_st = _stack_item_4; + tuple_st = _stack_item_3; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = sub_st; + _tos_cache3 = tuple_st; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (index >= PyTuple_GET_SIZE(tuple)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = sub_st; + _tos_cache3 = tuple_st; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = sub_st; + _tos_cache3 = tuple_st; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_TUPLE_INT_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef res; + _PyStackRef ts; + _PyStackRef ss; + sub_st = stack_pointer[-1]; + tuple_st = stack_pointer[-2]; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + STAT_INC(BINARY_OP, hit); + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + PyObject *res_o = PyTuple_GET_ITEM(tuple, index); + assert(res_o != NULL); + res = PyStackRef_FromPyObjectNew(res_o); + ts = tuple_st; + ss = sub_st; + _tos_cache2 = ss; + _tos_cache1 = ts; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_TUPLE_INT_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef res; + _PyStackRef ts; + _PyStackRef ss; + _PyStackRef _stack_item_0 = _tos_cache0; + sub_st = _stack_item_0; + tuple_st = stack_pointer[-1]; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + STAT_INC(BINARY_OP, hit); + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + PyObject *res_o = PyTuple_GET_ITEM(tuple, index); + assert(res_o != NULL); + res = PyStackRef_FromPyObjectNew(res_o); + ts = tuple_st; + ss = sub_st; + _tos_cache2 = ss; + _tos_cache1 = ts; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_TUPLE_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef res; + _PyStackRef ts; + _PyStackRef ss; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + sub_st = _stack_item_1; + tuple_st = _stack_item_0; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + STAT_INC(BINARY_OP, hit); + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + PyObject *res_o = PyTuple_GET_ITEM(tuple, index); + assert(res_o != NULL); + res = PyStackRef_FromPyObjectNew(res_o); + ts = tuple_st; + ss = sub_st; + _tos_cache2 = ss; + _tos_cache1 = ts; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_TUPLE_INT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef res; + _PyStackRef ts; + _PyStackRef ss; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + sub_st = _stack_item_2; + tuple_st = _stack_item_1; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + STAT_INC(BINARY_OP, hit); + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + PyObject *res_o = PyTuple_GET_ITEM(tuple, index); + assert(res_o != NULL); + res = PyStackRef_FromPyObjectNew(res_o); + ts = tuple_st; + ss = sub_st; + _tos_cache3 = ss; + _tos_cache2 = ts; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_TUPLE_INT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef tuple_st; + _PyStackRef res; + _PyStackRef ts; + _PyStackRef ss; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + sub_st = _stack_item_3; + tuple_st = _stack_item_2; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *tuple = PyStackRef_AsPyObjectBorrow(tuple_st); + assert(PyLong_CheckExact(sub)); + assert(PyTuple_CheckExact(tuple)); + STAT_INC(BINARY_OP, hit); + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + PyObject *res_o = PyTuple_GET_ITEM(tuple, index); + assert(res_o != NULL); + res = PyStackRef_FromPyObjectNew(res_o); + ts = tuple_st; + ss = sub_st; + _tos_cache4 = ss; + _tos_cache3 = ts; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_DICT_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + nos = stack_pointer[-2]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_DICT_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + nos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_0; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_DICT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + nos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_DICT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + nos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_DICT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + nos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_DICT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + nos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_ANY_DICT_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + nos = stack_pointer[-2]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_ANY_DICT_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + nos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_0; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_ANY_DICT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + nos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_ANY_DICT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + nos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_ANY_DICT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + nos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_ANY_DICT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + nos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_DICT_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + tos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_DICT_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + tos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_DICT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + tos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_DICT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + tos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_DICT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_DICT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_DICT_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + tos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_DICT_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + tos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_DICT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + tos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_DICT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + tos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_DICT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_DICT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENDICT_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + tos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENDICT_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + tos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENDICT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + tos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENDICT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + tos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENDICT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENDICT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenDict_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_DICT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef dict_st; + _PyStackRef res; + _PyStackRef ds; + _PyStackRef ss; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + sub_st = _stack_item_1; + dict_st = _stack_item_0; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); + assert(PyAnyDict_CheckExact(dict)); + STAT_INC(BINARY_OP, hit); + PyObject *res_o; + stack_pointer[0] = dict_st; + stack_pointer[1] = sub_st; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int rc = PyDict_GetItemRef(dict, sub, &res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (rc == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_SetKeyError(sub); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + if (rc <= 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + ds = dict_st; + ss = sub_st; + _tos_cache2 = ss; + _tos_cache1 = ds; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_CHECK_FUNC_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef container; + _PyStackRef getitem; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + container = _stack_item_0; + PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container)); + if (!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = container; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; + PyObject *getitem_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(ht->_spec_cache.getitem); + if (getitem_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = container; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + assert(PyFunction_Check(getitem_o)); + uint32_t cached_version = FT_ATOMIC_LOAD_UINT32_RELAXED(ht->_spec_cache.getitem_version); + if (((PyFunctionObject *)getitem_o)->func_version != cached_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = container; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + PyCodeObject *code = (PyCodeObject *)PyFunction_GET_CODE(getitem_o); + assert(code->co_argcount == 2); + if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = container; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + getitem = PyStackRef_FromPyObjectNew(getitem_o); + _tos_cache2 = getitem; + _tos_cache1 = _stack_item_1; + _tos_cache0 = container; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_INIT_CALL_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef getitem; + _PyStackRef sub; + _PyStackRef container; + _PyStackRef new_frame; + getitem = stack_pointer[-1]; + sub = stack_pointer[-2]; + container = stack_pointer[-3]; + STAT_INC(BINARY_OP, hit); + _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); + pushed_frame->localsplus[0] = container; + pushed_frame->localsplus[1] = sub; + frame->return_offset = 6u ; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_INIT_CALL_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef getitem; + _PyStackRef sub; + _PyStackRef container; + _PyStackRef new_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + getitem = _stack_item_0; + sub = stack_pointer[-1]; + container = stack_pointer[-2]; + STAT_INC(BINARY_OP, hit); + _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); + pushed_frame->localsplus[0] = container; + pushed_frame->localsplus[1] = sub; + frame->return_offset = 6u ; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_INIT_CALL_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef getitem; + _PyStackRef sub; + _PyStackRef container; + _PyStackRef new_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + getitem = _stack_item_1; + sub = _stack_item_0; + container = stack_pointer[-1]; + STAT_INC(BINARY_OP, hit); + _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); + pushed_frame->localsplus[0] = container; + pushed_frame->localsplus[1] = sub; + frame->return_offset = 6u ; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_INIT_CALL_r31: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef getitem; + _PyStackRef sub; + _PyStackRef container; + _PyStackRef new_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + getitem = _stack_item_2; + sub = _stack_item_1; + container = _stack_item_0; + STAT_INC(BINARY_OP, hit); + _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); + pushed_frame->localsplus[0] = container; + pushed_frame->localsplus[1] = sub; + frame->return_offset = 6u ; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_INIT_CALL_r42: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef getitem; + _PyStackRef sub; + _PyStackRef container; + _PyStackRef new_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + getitem = _stack_item_3; + sub = _stack_item_2; + container = _stack_item_1; + STAT_INC(BINARY_OP, hit); + _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); + pushed_frame->localsplus[0] = container; + pushed_frame->localsplus[1] = sub; + frame->return_offset = 6u ; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache1 = new_frame; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BINARY_OP_SUBSCR_INIT_CALL_r53: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef getitem; + _PyStackRef sub; + _PyStackRef container; + _PyStackRef new_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + getitem = _stack_item_4; + sub = _stack_item_3; + container = _stack_item_2; + STAT_INC(BINARY_OP, hit); + _PyInterpreterFrame* pushed_frame = _PyFrame_PushUnchecked(tstate, getitem, 2, frame); + pushed_frame->localsplus[0] = container; + pushed_frame->localsplus[1] = sub; + frame->return_offset = 6u ; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache2 = new_frame; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LIST_APPEND_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef v; + _PyStackRef list; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + v = _stack_item_0; + list = stack_pointer[-1 - (oparg-1)]; + int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), + PyStackRef_AsPyObjectSteal(v)); + if (err < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SET_ADD_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef v; + _PyStackRef set; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + v = _stack_item_0; + set = stack_pointer[-1 - (oparg-1)]; + stack_pointer[0] = v; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _PySet_AddTakeRef((PySetObject *)PyStackRef_AsPyObjectBorrow(set), + PyStackRef_AsPyObjectSteal(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err) { + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_SUBSCR_r30: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub; + _PyStackRef container; + _PyStackRef v; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + sub = _stack_item_2; + container = _stack_item_1; + v = _stack_item_0; + stack_pointer[0] = v; + stack_pointer[1] = container; + stack_pointer[2] = sub; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); + _PyStackRef tmp = sub; + sub = PyStackRef_NULL; + stack_pointer[-1] = sub; + PyStackRef_CLOSE(tmp); + tmp = container; + container = PyStackRef_NULL; + stack_pointer[-2] = container; + PyStackRef_CLOSE(tmp); + tmp = v; + v = PyStackRef_NULL; + stack_pointer[-3] = v; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_SUBSCR_LIST_INT_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub_st; + _PyStackRef list_st; + _PyStackRef value; + _PyStackRef ls; + _PyStackRef ss; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + sub_st = _stack_item_2; + list_st = _stack_item_1; + value = _stack_item_0; + PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st); + PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); + assert(PyLong_CheckExact(sub)); + assert(PyList_CheckExact(list)); + if (!_PyLong_IsNonNegativeCompact((PyLongObject *)sub)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = sub_st; + _tos_cache1 = list_st; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + Py_ssize_t index = ((PyLongObject*)sub)->long_value.ob_digit[0]; + if (!LOCK_OBJECT(list)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = sub_st; + _tos_cache1 = list_st; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + if (index >= PyList_GET_SIZE(list)) { + UNLOCK_OBJECT(list); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = sub_st; + _tos_cache1 = list_st; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + } + STAT_INC(STORE_SUBSCR, hit); + PyObject *old_value = PyList_GET_ITEM(list, index); + FT_ATOMIC_STORE_PTR_RELEASE(_PyList_ITEMS(list)[index], + PyStackRef_AsPyObjectSteal(value)); + assert(old_value != NULL); + UNLOCK_OBJECT(list); + ls = list_st; + ss = sub_st; + stack_pointer[0] = ls; + stack_pointer[1] = ss; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_DECREF(old_value); + stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache1 = ss; + _tos_cache0 = ls; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_SUBSCR_DICT_r31: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub; + _PyStackRef dict_st; + _PyStackRef value; + _PyStackRef st; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + sub = _stack_item_2; + dict_st = _stack_item_1; + value = _stack_item_0; + PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); + assert(PyDict_CheckExact(dict)); + STAT_INC(STORE_SUBSCR, hit); + stack_pointer[0] = value; + stack_pointer[1] = dict_st; + stack_pointer[2] = sub; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _PyDict_SetItem_Take2((PyDictObject *)dict, + PyStackRef_AsPyObjectSteal(sub), + PyStackRef_AsPyObjectSteal(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err) { + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(dict_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + st = dict_st; + _tos_cache0 = st; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _DELETE_SUBSCR_r20: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef sub; + _PyStackRef container; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + sub = _stack_item_1; + container = _stack_item_0; + stack_pointer[0] = container; + stack_pointer[1] = sub; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), + PyStackRef_AsPyObjectBorrow(sub)); + _PyStackRef tmp = sub; + sub = PyStackRef_NULL; + stack_pointer[-1] = sub; + PyStackRef_CLOSE(tmp); + tmp = container; + container = PyStackRef_NULL; + stack_pointer[-2] = container; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CALL_INTRINSIC_1_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + value = _stack_item_0; + assert(oparg <= MAX_INTRINSIC_1); + stack_pointer[0] = value; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CALL_INTRINSIC_2_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value1_st; + _PyStackRef value2_st; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + value1_st = _stack_item_1; + value2_st = _stack_item_0; + assert(oparg <= MAX_INTRINSIC_2); + PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st); + PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st); + stack_pointer[0] = value2_st; + stack_pointer[1] = value1_st; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); + _PyStackRef tmp = value1_st; + value1_st = PyStackRef_NULL; + stack_pointer[-1] = value1_st; + PyStackRef_CLOSE(tmp); + tmp = value2_st; + value2_st = PyStackRef_NULL; + stack_pointer[-2] = value2_st; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _RETURN_VALUE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef retval; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + retval = _stack_item_0; + assert(frame->owner != FRAME_OWNED_BY_INTERPRETER); + _PyStackRef temp = PyStackRef_MakeHeapSafe(retval); + _PyFrame_SetStackPointer(frame, stack_pointer); + assert(STACK_LEVEL() == 0); + _Py_LeaveRecursiveCallPy(tstate); + _PyInterpreterFrame *dying = frame; + frame = tstate->current_frame = dying->previous; + _PyEval_FrameClearAndPop(tstate, dying); + stack_pointer = _PyFrame_GetStackPointer(frame); + LOAD_IP(frame->return_offset); + res = temp; + LLTRACE_RESUME_FRAME(); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GET_AITER_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef obj; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + obj = _stack_item_0; + unaryfunc getter = NULL; + PyObject *obj_o = PyStackRef_AsPyObjectBorrow(obj); + PyObject *iter_o; + PyTypeObject *type = Py_TYPE(obj_o); + if (type->tp_as_async != NULL) { + getter = type->tp_as_async->am_aiter; + } + if (getter == NULL) { + stack_pointer[0] = obj; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_Format(tstate, PyExc_TypeError, + "'async for' requires an object with " + "__aiter__ method, got %.100s", + type->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(obj); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + stack_pointer[0] = obj; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + iter_o = (*getter)(obj_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(obj); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (iter_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (Py_TYPE(iter_o)->tp_as_async == NULL || + Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_Format(tstate, PyExc_TypeError, + "'async for' received an object from __aiter__ " + "that does not implement __anext__: %.100s", + Py_TYPE(iter_o)->tp_name); + Py_DECREF(iter_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + iter = PyStackRef_FromPyObjectSteal(iter_o); + _tos_cache0 = iter; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GET_ANEXT_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef aiter; + _PyStackRef awaitable; + _PyStackRef _stack_item_0 = _tos_cache0; + aiter = _stack_item_0; + stack_pointer[0] = aiter; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (awaitable_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + awaitable = PyStackRef_FromPyObjectSteal(awaitable_o); + _tos_cache1 = awaitable; + _tos_cache0 = aiter; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GET_AWAITABLE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iterable; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + iterable = _stack_item_0; + stack_pointer[0] = iterable; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(iterable); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (iter_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + iter = PyStackRef_FromPyObjectSteal(iter_o); + _tos_cache0 = iter; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _SEND is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ + + case _SEND_GEN_FRAME_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef v; + _PyStackRef receiver; + _PyStackRef gen_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + v = _stack_item_1; + receiver = _stack_item_0; + PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(receiver); + if (Py_TYPE(gen) != &PyGen_Type && Py_TYPE(gen) != &PyCoro_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = v; + _tos_cache0 = receiver; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + if (!gen_try_set_executing((PyGenObject *)gen)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = v; + _tos_cache0 = receiver; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(SEND, hit); + _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; + _PyFrame_StackPush(pushed_frame, PyStackRef_MakeHeapSafe(v)); + gen->gi_exc_state.previous_item = tstate->exc_info; + tstate->exc_info = &gen->gi_exc_state; + assert( 2u + oparg <= UINT16_MAX); + frame->return_offset = (uint16_t)( 2u + oparg); + pushed_frame->previous = frame; + gen_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache1 = gen_frame; + _tos_cache0 = receiver; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _YIELD_VALUE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef retval; + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + retval = _stack_item_0; + assert(frame->owner != FRAME_OWNED_BY_INTERPRETER); + frame->instr_ptr++; + PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); + assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); + assert(oparg == 0 || oparg == 1); + _PyStackRef temp = retval; + _PyFrame_SetStackPointer(frame, stack_pointer); + tstate->exc_info = gen->gi_exc_state.previous_item; + gen->gi_exc_state.previous_item = NULL; + _Py_LeaveRecursiveCallPy(tstate); + _PyInterpreterFrame *gen_frame = frame; + frame = tstate->current_frame = frame->previous; + gen_frame->previous = NULL; + ((_PyThreadStateImpl *)tstate)->generator_return_kind = GENERATOR_YIELD; + FT_ATOMIC_STORE_INT8_RELEASE(gen->gi_frame_state, FRAME_SUSPENDED + oparg); + assert(INLINE_CACHE_ENTRIES_SEND == INLINE_CACHE_ENTRIES_FOR_ITER); + #if TIER_ONE + assert(frame->instr_ptr->op.code == INSTRUMENTED_LINE || + frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); + #endif + stack_pointer = _PyFrame_GetStackPointer(frame); + LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); + value = PyStackRef_MakeHeapSafe(temp); + LLTRACE_RESUME_FRAME(); + _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _POP_EXCEPT_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef exc_value; + _PyStackRef _stack_item_0 = _tos_cache0; + exc_value = _stack_item_0; + _PyErr_StackItem *exc_info = tstate->exc_info; + stack_pointer[0] = exc_value; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_XSETREF(exc_info->exc_value, + PyStackRef_IsNone(exc_value) + ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_COMMON_CONSTANT_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + oparg = CURRENT_OPARG(); + assert(oparg < NUM_COMMON_CONSTANTS); + value = PyStackRef_FromPyObjectNew(tstate->interp->common_consts[oparg]); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_COMMON_CONSTANT_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + assert(oparg < NUM_COMMON_CONSTANTS); + value = PyStackRef_FromPyObjectNew(tstate->interp->common_consts[oparg]); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_COMMON_CONSTANT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + assert(oparg < NUM_COMMON_CONSTANTS); + value = PyStackRef_FromPyObjectNew(tstate->interp->common_consts[oparg]); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_COMMON_CONSTANT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + assert(oparg < NUM_COMMON_CONSTANTS); + value = PyStackRef_FromPyObjectNew(tstate->interp->common_consts[oparg]); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_COMMON_CONSTANT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + assert(oparg < NUM_COMMON_CONSTANTS); + value = PyStackRef_FromPyObjectNew(tstate->interp->common_consts[oparg]); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_BUILD_CLASS_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef bc; + int err; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *bc_o = _PyMapping_GetOptionalItem2(BUILTINS(), &_Py_ID(__build_class__), &err); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (bc_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_SetString(tstate, PyExc_NameError, + "__build_class__ not found"); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + bc = PyStackRef_FromPyObjectSteal(bc_o); + _tos_cache0 = bc; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_NAME_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef v; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + v = _stack_item_0; + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *ns = LOCALS(); + int err; + if (ns == NULL) { + stack_pointer[0] = v; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_Format(tstate, PyExc_SystemError, + "no locals found when storing %R", name); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(v); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (PyDict_CheckExact(ns)) { + stack_pointer[0] = v; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else { + stack_pointer[0] = v; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(v); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _DELETE_NAME_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + oparg = CURRENT_OPARG(); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *ns = LOCALS(); + int err; + if (ns == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_Format(tstate, PyExc_SystemError, + "no locals when deleting %R", name); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + err = PyObject_DelItem(ns, name); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err != 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, + NAME_ERROR_MSG, + name); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _UNPACK_SEQUENCE_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef seq; + _PyStackRef *top; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + seq = _stack_item_0; + top = &stack_pointer[oparg]; + PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq); + _PyFrame_SetStackPointer(frame, stack_pointer); + int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top); + Py_DECREF(seq_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res == 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _UNPACK_SEQUENCE_TWO_TUPLE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef seq; + _PyStackRef val1; + _PyStackRef val0; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + seq = _stack_item_0; + assert(oparg == 2); + PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); + assert(PyTuple_CheckExact(seq_o)); + if (PyTuple_GET_SIZE(seq_o) != 2) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = seq; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(UNPACK_SEQUENCE, hit); + val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0)); + val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1)); + stack_pointer[0] = val1; + stack_pointer[1] = val0; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(seq); + stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache1 = val0; + _tos_cache0 = val1; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _UNPACK_SEQUENCE_TUPLE_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef seq; + _PyStackRef *values; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + seq = _stack_item_0; + values = &stack_pointer[0]; + PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); + assert(PyTuple_CheckExact(seq_o)); + if (PyTuple_GET_SIZE(seq_o) != oparg) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = seq; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(UNPACK_SEQUENCE, hit); + PyObject **items = _PyTuple_ITEMS(seq_o); + for (int i = oparg; --i >= 0; ) { + *values++ = PyStackRef_FromPyObjectNew(items[i]); + } + stack_pointer += oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(seq); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _UNPACK_SEQUENCE_LIST_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef seq; + _PyStackRef *values; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + seq = _stack_item_0; + values = &stack_pointer[0]; + PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); + assert(PyList_CheckExact(seq_o)); + if (!LOCK_OBJECT(seq_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = seq; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + if (PyList_GET_SIZE(seq_o) != oparg) { + UNLOCK_OBJECT(seq_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = seq; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + STAT_INC(UNPACK_SEQUENCE, hit); + PyObject **items = _PyList_ITEMS(seq_o); + for (int i = oparg; --i >= 0; ) { + *values++ = PyStackRef_FromPyObjectNew(items[i]); + } + UNLOCK_OBJECT(seq_o); + stack_pointer += oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(seq); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _UNPACK_EX_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef seq; + _PyStackRef *top; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + seq = _stack_item_0; + top = &stack_pointer[1 + (oparg & 0xFF) + (oparg >> 8)]; + PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq); + _PyFrame_SetStackPointer(frame, stack_pointer); + int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg & 0xFF, oparg >> 8, top); + Py_DECREF(seq_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res == 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_ATTR_r20: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef v; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + owner = _stack_item_1; + v = _stack_item_0; + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer[0] = v; + stack_pointer[1] = owner; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), + name, PyStackRef_AsPyObjectBorrow(v)); + _PyStackRef tmp = owner; + owner = PyStackRef_NULL; + stack_pointer[-1] = owner; + PyStackRef_CLOSE(tmp); + tmp = v; + v = PyStackRef_NULL; + stack_pointer[-2] = v; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _DELETE_ATTR_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + owner = _stack_item_0; + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer[0] = owner; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(owner); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_GLOBAL_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef v; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + v = _stack_item_0; + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer[0] = v; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(v); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _DELETE_GLOBAL_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + oparg = CURRENT_OPARG(); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyDict_Pop(GLOBALS(), name, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (err == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, + NAME_ERROR_MSG, name); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _LOAD_LOCALS_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef locals; + PyObject *l = LOCALS(); + if (l == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_SetString(tstate, PyExc_SystemError, + "no locals found"); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + locals = PyStackRef_FromPyObjectNew(l); + _tos_cache0 = locals; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_LOCALS_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef locals; + _PyStackRef _stack_item_0 = _tos_cache0; + PyObject *l = LOCALS(); + if (l == NULL) { + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_SetString(tstate, PyExc_SystemError, + "no locals found"); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + locals = PyStackRef_FromPyObjectNew(l); + _tos_cache1 = locals; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_LOCALS_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef locals; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + PyObject *l = LOCALS(); + if (l == NULL) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_SetString(tstate, PyExc_SystemError, + "no locals found"); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + locals = PyStackRef_FromPyObjectNew(l); + _tos_cache2 = locals; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_LOCALS_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef locals; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + PyObject *l = LOCALS(); + if (l == NULL) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_SetString(tstate, PyExc_SystemError, + "no locals found"); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + locals = PyStackRef_FromPyObjectNew(l); + _tos_cache3 = locals; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_LOCALS_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef locals; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *l = LOCALS(); + if (l == NULL) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_SetString(tstate, PyExc_SystemError, + "no locals found"); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + locals = PyStackRef_FromPyObjectNew(l); + _tos_cache4 = locals; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _LOAD_FROM_DICT_OR_GLOBALS is not a viable micro-op for tier 2 because it has both popping and not-popping errors */ + + case _LOAD_NAME_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef v; + oparg = CURRENT_OPARG(); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *v_o = _PyEval_LoadName(tstate, frame, name); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (v_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (PyLazyImport_CheckExact(v_o)) { + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (l_v == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_DECREF(v_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyDict_SetItem(GLOBALS(), name, l_v); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_DECREF(v_o); + Py_DECREF(l_v); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_SETREF(v_o, l_v); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + v = PyStackRef_FromPyObjectSteal(v_o); + _tos_cache0 = v; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_GLOBAL_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *res; + oparg = CURRENT_OPARG(); + res = &stack_pointer[0]; + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (PyStackRef_IsNull(*res)) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _PUSH_NULL_CONDITIONAL_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *null; + oparg = CURRENT_OPARG(); + null = &stack_pointer[0]; + if (oparg & 1) { + null[0] = PyStackRef_NULL; + } + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += (oparg & 1); + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_GLOBALS_VERSION_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); + PyDictObject *dict = (PyDictObject *)GLOBALS(); + if (!PyDict_CheckExact(dict)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_GLOBALS_VERSION_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); + PyDictObject *dict = (PyDictObject *)GLOBALS(); + if (!PyDict_CheckExact(dict)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_GLOBALS_VERSION_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); + PyDictObject *dict = (PyDictObject *)GLOBALS(); + if (!PyDict_CheckExact(dict)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_GLOBALS_VERSION_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); + PyDictObject *dict = (PyDictObject *)GLOBALS(); + if (!PyDict_CheckExact(dict)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_GLOBALS_VERSION_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); + PyDictObject *dict = (PyDictObject *)GLOBALS(); + if (!PyDict_CheckExact(dict)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_GLOBALS_VERSION_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); + PyDictObject *dict = (PyDictObject *)GLOBALS(); + if (!PyDict_CheckExact(dict)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_GLOBAL_MODULE_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef res; + uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); + uint16_t index = (uint16_t)CURRENT_OPERAND1_16(); + PyDictObject *dict = (PyDictObject *)GLOBALS(); + if (!PyDict_CheckExact(dict)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(keys); + assert(index < DK_SIZE(keys)); + PyObject *res_o = FT_ATOMIC_LOAD_PTR_RELAXED(entries[index].me_value); + if (res_o == NULL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #if Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(&entries[index].me_value, res_o, &res); + if (!increfed) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #else + res = PyStackRef_FromPyObjectNew(res_o); + #endif + STAT_INC(LOAD_GLOBAL, hit); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_GLOBAL_BUILTINS_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef res; + uint16_t version = (uint16_t)CURRENT_OPERAND0_16(); + uint16_t index = (uint16_t)CURRENT_OPERAND1_16(); + PyDictObject *dict = (PyDictObject *)BUILTINS(); + if (!PyDict_CheckExact(dict)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(keys); + PyObject *res_o = FT_ATOMIC_LOAD_PTR_RELAXED(entries[index].me_value); + if (res_o == NULL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #if Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(&entries[index].me_value, res_o, &res); + if (!increfed) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #else + res = PyStackRef_FromPyObjectNew(res_o); + #endif + STAT_INC(LOAD_GLOBAL, hit); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _DELETE_FAST_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + oparg = CURRENT_OPARG(); + _PyStackRef v = GETLOCAL(oparg); + if (PyStackRef_IsNull(v)) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, + UNBOUNDLOCAL_ERROR_MSG, + PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) + ); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = PyStackRef_NULL; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_XCLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _MAKE_CELL_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + oparg = CURRENT_OPARG(); + PyObject *initial = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); + PyObject *cell = PyCell_New(initial); + if (cell == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyStackRef tmp = GETLOCAL(oparg); + GETLOCAL(oparg) = PyStackRef_FromPyObjectSteal(cell); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_XCLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _DELETE_DEREF_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + oparg = CURRENT_OPARG(); + PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); + PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); + if (oldobj == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_DECREF(oldobj); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _LOAD_FROM_DICT_OR_DEREF_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef class_dict_st; + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + class_dict_st = _stack_item_0; + PyObject *name; + PyObject *class_dict = PyStackRef_AsPyObjectBorrow(class_dict_st); + assert(class_dict); + assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); + name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); + int err; + stack_pointer[0] = class_dict_st; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject* value_o = _PyMapping_GetOptionalItem2(class_dict, name, &err); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (!value_o) { + PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); + value_o = PyCell_GetRef(cell); + if (value_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + } + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(class_dict_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + value = PyStackRef_FromPyObjectSteal(value_o); + _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_DEREF_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + oparg = CURRENT_OPARG(); + PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); + _PyFrame_SetStackPointer(frame, stack_pointer); + value = _PyCell_GetStackRef(cell); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (PyStackRef_IsNull(value)) { + stack_pointer[0] = value; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_DEREF_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef v; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + v = _stack_item_0; + PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); + stack_pointer[0] = v; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_FREE_VARS_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + oparg = CURRENT_OPARG(); + PyCodeObject *co = _PyFrame_GetCode(frame); + assert(PyStackRef_FunctionCheck(frame->f_funcobj)); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); + PyObject *closure = func->func_closure; + assert(oparg == co->co_nfreevars); + int offset = co->co_nlocalsplus - oparg; + for (int i = 0; i < oparg; ++i) { + PyObject *o = PyTuple_GET_ITEM(closure, i); + frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + } + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _COPY_FREE_VARS_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + PyCodeObject *co = _PyFrame_GetCode(frame); + assert(PyStackRef_FunctionCheck(frame->f_funcobj)); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); + PyObject *closure = func->func_closure; + assert(oparg == co->co_nfreevars); + int offset = co->co_nlocalsplus - oparg; + for (int i = 0; i < oparg; ++i) { + PyObject *o = PyTuple_GET_ITEM(closure, i); + frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + } + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_FREE_VARS_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + PyCodeObject *co = _PyFrame_GetCode(frame); + assert(PyStackRef_FunctionCheck(frame->f_funcobj)); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); + PyObject *closure = func->func_closure; + assert(oparg == co->co_nfreevars); + int offset = co->co_nlocalsplus - oparg; + for (int i = 0; i < oparg; ++i) { + PyObject *o = PyTuple_GET_ITEM(closure, i); + frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_FREE_VARS_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + PyCodeObject *co = _PyFrame_GetCode(frame); + assert(PyStackRef_FunctionCheck(frame->f_funcobj)); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); + PyObject *closure = func->func_closure; + assert(oparg == co->co_nfreevars); + int offset = co->co_nlocalsplus - oparg; + for (int i = 0; i < oparg; ++i) { + PyObject *o = PyTuple_GET_ITEM(closure, i); + frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_FREE_VARS_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + PyCodeObject *co = _PyFrame_GetCode(frame); + assert(PyStackRef_FunctionCheck(frame->f_funcobj)); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); + PyObject *closure = func->func_closure; + assert(oparg == co->co_nfreevars); + int offset = co->co_nlocalsplus - oparg; + for (int i = 0; i < oparg; ++i) { + PyObject *o = PyTuple_GET_ITEM(closure, i); + frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_FREE_VARS_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = CURRENT_OPARG(); + PyCodeObject *co = _PyFrame_GetCode(frame); + assert(PyStackRef_FunctionCheck(frame->f_funcobj)); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); + PyObject *closure = func->func_closure; + assert(oparg == co->co_nfreevars); + int offset = co->co_nlocalsplus - oparg; + for (int i = 0; i < oparg; ++i) { + PyObject *o = PyTuple_GET_ITEM(closure, i); + frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BUILD_STRING_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *pieces; + _PyStackRef str; + oparg = CURRENT_OPARG(); + pieces = &stack_pointer[-oparg]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *str_o = _Py_BuildString_StackRefSteal(pieces, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (str_o == NULL) { + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + str = PyStackRef_FromPyObjectSteal(str_o); + _tos_cache0 = str; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BUILD_INTERPOLATION_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *format; + _PyStackRef str; + _PyStackRef value; + _PyStackRef interpolation; + oparg = CURRENT_OPARG(); + format = &stack_pointer[-(oparg & 1)]; + str = stack_pointer[-1 - (oparg & 1)]; + value = stack_pointer[-2 - (oparg & 1)]; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + PyObject *str_o = PyStackRef_AsPyObjectBorrow(str); + int conversion = oparg >> 2; + PyObject *format_o; + if (oparg & 1) { + format_o = PyStackRef_AsPyObjectBorrow(format[0]); + } + else { + format_o = &_Py_STR(empty); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *interpolation_o = _PyInterpolation_Build(value_o, str_o, conversion, format_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (oparg & 1) { + stack_pointer += -(oparg & 1); + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(format[0]); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else { + stack_pointer += -(oparg & 1); + } + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(str); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (interpolation_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + interpolation = PyStackRef_FromPyObjectSteal(interpolation_o); + _tos_cache0 = interpolation; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BUILD_TEMPLATE_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef interpolations; + _PyStackRef strings; + _PyStackRef template; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + interpolations = _stack_item_1; + strings = _stack_item_0; + PyObject *strings_o = PyStackRef_AsPyObjectBorrow(strings); + PyObject *interpolations_o = PyStackRef_AsPyObjectBorrow(interpolations); + stack_pointer[0] = strings; + stack_pointer[1] = interpolations; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(interpolations); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(strings); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (template_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + template = PyStackRef_FromPyObjectSteal(template_o); + _tos_cache0 = template; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BUILD_TUPLE_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *values; + _PyStackRef tup; + oparg = CURRENT_OPARG(); + values = &stack_pointer[-oparg]; + PyObject *tup_o = _PyTuple_FromStackRefStealOnSuccess(values, oparg); + if (tup_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + tup = PyStackRef_FromPyObjectStealMortal(tup_o); + _tos_cache0 = tup; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BUILD_LIST_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *values; + _PyStackRef list; + oparg = CURRENT_OPARG(); + values = &stack_pointer[-oparg]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *list_o = _PyList_FromStackRefStealOnSuccess(values, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (list_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + list = PyStackRef_FromPyObjectStealMortal(list_o); + _tos_cache0 = list; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LIST_EXTEND_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iterable_st; + _PyStackRef list_st; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + iterable_st = _stack_item_0; + list_st = stack_pointer[-1 - (oparg-1)]; + PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); + PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); + stack_pointer[0] = iterable_st; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (none_val == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (matches && + (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) + { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_Clear(tstate); + _PyErr_Format(tstate, PyExc_TypeError, + "Value after * must be an iterable, not %.200s", + Py_TYPE(iterable)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(iterable_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + assert(Py_IsNone(none_val)); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(iterable_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SET_UPDATE_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iterable; + _PyStackRef set; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + iterable = _stack_item_0; + set = stack_pointer[-1 - (oparg-1)]; + stack_pointer[0] = iterable; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), + PyStackRef_AsPyObjectBorrow(iterable)); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(iterable); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BUILD_SET_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *values; + _PyStackRef set; + oparg = CURRENT_OPARG(); + values = &stack_pointer[-oparg]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *set_o = PySet_New(NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (set_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp; + for (int _i = oparg; --_i >= 0;) { + tmp = values[_i]; + values[_i] = PyStackRef_NULL; + PyStackRef_CLOSE(tmp); + } + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + int err = 0; + for (Py_ssize_t i = 0; i < oparg; i++) { + _PyStackRef value = values[i]; + values[i] = PyStackRef_NULL; + if (err == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); + err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else { + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + } + if (err) { + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_DECREF(set_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + set = PyStackRef_FromPyObjectStealMortal(set_o); + _tos_cache0 = set; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _BUILD_MAP_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *values; + _PyStackRef map; + oparg = CURRENT_OPARG(); + values = &stack_pointer[-oparg*2]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *map_o = _Py_BuildMap_StackRefSteal(values, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (map_o == NULL) { + stack_pointer += -oparg*2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + map = PyStackRef_FromPyObjectStealMortal(map_o); + _tos_cache0 = map; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -oparg*2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SETUP_ANNOTATIONS_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + if (LOCALS() == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_Format(tstate, PyExc_SystemError, + "no locals found when setting up annotations"); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + int err; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject* ann_dict = _PyMapping_GetOptionalItem2(LOCALS(), &_Py_ID(__annotations__), &err); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (ann_dict == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + ann_dict = PyDict_New(); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (ann_dict == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), + ann_dict); + Py_DECREF(ann_dict); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + } + else { + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_DECREF(ann_dict); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _DICT_UPDATE_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef update; + _PyStackRef dict; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + update = _stack_item_0; + dict = stack_pointer[-1 - (oparg - 1)]; + PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + stack_pointer[0] = update; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = PyDict_Update(dict_o, update_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); + int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (matches) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_Format(tstate, PyExc_TypeError, + "'%.200s' object is not a mapping", + Py_TYPE(update_o)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(update); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(update); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _DICT_MERGE_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef update; + _PyStackRef dict; + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + update = _stack_item_0; + dict = stack_pointer[-1 - (oparg - 1)]; + callable = stack_pointer[-4 - (oparg - 1)]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + stack_pointer[0] = update; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _PyDict_MergeEx(dict_o, update_o, 2); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FormatKwargsError(tstate, callable_o, update_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(update); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(update); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MAP_ADD_r20: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef key; + _PyStackRef dict_st; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + value = _stack_item_1; + key = _stack_item_0; + dict_st = stack_pointer[-1 - (oparg - 1)]; + PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); + assert(PyDict_CheckExact(dict)); + stack_pointer[0] = key; + stack_pointer[1] = value; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _PyDict_SetItem_Take2( + (PyDictObject *)dict, + PyStackRef_AsPyObjectSteal(key), + PyStackRef_AsPyObjectSteal(value) + ); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err != 0) { + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_SUPER_ATTR_ATTR_r31: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef self_st; + _PyStackRef class_st; + _PyStackRef global_super_st; + _PyStackRef attr_st; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + self_st = _stack_item_2; + class_st = _stack_item_1; + global_super_st = _stack_item_0; + PyObject *global_super = PyStackRef_AsPyObjectBorrow(global_super_st); + PyObject *class = PyStackRef_AsPyObjectBorrow(class_st); + PyObject *self = PyStackRef_AsPyObjectBorrow(self_st); + assert(!(oparg & 1)); + if (global_super != (PyObject *)&PySuper_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = self_st; + _tos_cache1 = class_st; + _tos_cache0 = global_super_st; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + if (!PyType_Check(class)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = self_st; + _tos_cache1 = class_st; + _tos_cache0 = global_super_st; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(LOAD_SUPER_ATTR, hit); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + stack_pointer[0] = global_super_st; + stack_pointer[1] = class_st; + stack_pointer[2] = self_st; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); + _PyStackRef tmp = self_st; + self_st = PyStackRef_NULL; + stack_pointer[-1] = self_st; + PyStackRef_CLOSE(tmp); + tmp = class_st; + class_st = PyStackRef_NULL; + stack_pointer[-2] = class_st; + PyStackRef_CLOSE(tmp); + tmp = global_super_st; + global_super_st = PyStackRef_NULL; + stack_pointer[-3] = global_super_st; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (attr == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + attr_st = PyStackRef_FromPyObjectSteal(attr); + _tos_cache0 = attr_st; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_SUPER_ATTR_METHOD_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef self_st; + _PyStackRef class_st; + _PyStackRef global_super_st; + _PyStackRef attr; + _PyStackRef self_or_null; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + self_st = _stack_item_2; + class_st = _stack_item_1; + global_super_st = _stack_item_0; + PyObject *global_super = PyStackRef_AsPyObjectBorrow(global_super_st); + PyObject *class = PyStackRef_AsPyObjectBorrow(class_st); + PyObject *self = PyStackRef_AsPyObjectBorrow(self_st); + assert(oparg & 1); + if (global_super != (PyObject *)&PySuper_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = self_st; + _tos_cache1 = class_st; + _tos_cache0 = global_super_st; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + if (!PyType_Check(class)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = self_st; + _tos_cache1 = class_st; + _tos_cache0 = global_super_st; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(LOAD_SUPER_ATTR, hit); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + PyTypeObject *cls = (PyTypeObject *)class; + int method_found = 0; + PyObject *attr_o; + { + int *method_found_ptr = &method_found; + stack_pointer[0] = global_super_st; + stack_pointer[1] = class_st; + stack_pointer[2] = self_st; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + attr_o = _PySuper_Lookup(cls, self, name, + Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? method_found_ptr : NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + if (attr_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (method_found) { + self_or_null = self_st; + } else { + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(self_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + self_or_null = PyStackRef_NULL; + stack_pointer += 1; + } + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp = global_super_st; + global_super_st = self_or_null; + stack_pointer[-2] = global_super_st; + PyStackRef_CLOSE(tmp); + tmp = class_st; + class_st = PyStackRef_NULL; + stack_pointer[-1] = class_st; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + attr = PyStackRef_FromPyObjectSteal(attr_o); + _tos_cache1 = self_or_null; + _tos_cache0 = attr; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef *self_or_null; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + owner = _stack_item_0; + self_or_null = &stack_pointer[1]; + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 1); + if (oparg & 1) { + stack_pointer[0] = owner; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + attr = _Py_LoadAttr_StackRefSteal(tstate, owner, name, self_or_null); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (PyStackRef_IsNull(attr)) { + stack_pointer[-1] = attr; + stack_pointer += (oparg&1); + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + } + else { + stack_pointer[0] = owner; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + attr = _PyObject_GetAttrStackRef(PyStackRef_AsPyObjectBorrow(owner), name); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer[-1] = attr; + stack_pointer += (oparg&1); + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(owner); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (PyStackRef_IsNull(attr)) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + stack_pointer += -(oparg&1); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[-1] = attr; + stack_pointer += (oparg&1); + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + owner = stack_pointer[-1]; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + owner = _stack_item_4; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_AND_LOCK_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + owner = stack_pointer[-1]; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(type_version != 0); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *tp = Py_TYPE(owner_o); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_AND_LOCK_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(type_version != 0); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *tp = Py_TYPE(owner_o); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_AND_LOCK_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(type_version != 0); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *tp = Py_TYPE(owner_o); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_AND_LOCK_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(type_version != 0); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *tp = Py_TYPE(owner_o); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_AND_LOCK_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(type_version != 0); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *tp = Py_TYPE(owner_o); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TYPE_VERSION_AND_LOCK_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + owner = _stack_item_4; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(type_version != 0); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *tp = Py_TYPE(owner_o); + if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_MANAGED_OBJECT_HAS_VALUES_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + owner = stack_pointer[-1]; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_MANAGED_OBJECT_HAS_VALUES_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_MANAGED_OBJECT_HAS_VALUES_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_MANAGED_OBJECT_HAS_VALUES_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_MANAGED_OBJECT_HAS_VALUES_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_MANAGED_OBJECT_HAS_VALUES_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + owner = _stack_item_4; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_INSTANCE_VALUE_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + owner = stack_pointer[-1]; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(*value_ptr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(value_ptr, attr_o, &attr); + if (!increfed) { + if (true) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache1 = o; + _tos_cache0 = attr; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_INSTANCE_VALUE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(*value_ptr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(value_ptr, attr_o, &attr); + if (!increfed) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache1 = o; + _tos_cache0 = attr; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_INSTANCE_VALUE_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(*value_ptr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(value_ptr, attr_o, &attr); + if (!increfed) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache2 = o; + _tos_cache1 = attr; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_INSTANCE_VALUE_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(*value_ptr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(value_ptr, attr_o, &attr); + if (!increfed) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache3 = o; + _tos_cache2 = attr; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_INSTANCE_VALUE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(*value_ptr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(value_ptr, attr_o, &attr); + if (!increfed) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache4 = o; + _tos_cache3 = attr; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_MODULE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + uint32_t dict_version = (uint32_t)CURRENT_OPERAND0_32(); + uint16_t index = (uint16_t)CURRENT_OPERAND1_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (Py_TYPE(owner_o)->tp_getattro != PyModule_Type.tp_getattro) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner_o)->md_dict; + assert(dict != NULL); + PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != dict_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + assert(keys->dk_kind == DICT_KEYS_UNICODE); + assert(index < FT_ATOMIC_LOAD_SSIZE_RELAXED(keys->dk_nentries)); + PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(keys) + index; + PyObject *attr_o = FT_ATOMIC_LOAD_PTR_RELAXED(ep->me_value); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(&ep->me_value, attr_o, &attr); + if (!increfed) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache1 = o; + _tos_cache0 = attr; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_WITH_HINT_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + owner = _stack_item_0; + uint16_t hint = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_MANAGED_DICT); + PyDictObject *dict = _PyObject_GetManagedDict(owner_o); + if (dict == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + PyDictKeysObject *dk = FT_ATOMIC_LOAD_PTR(dict->ma_keys); + assert(PyDict_CheckExact((PyObject *)dict)); + #ifdef Py_GIL_DISABLED + if (!_Py_IsOwnedByCurrentThread((PyObject *)dict) && !_PyObject_GC_IS_SHARED(dict)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + #endif + PyObject *attr_o; + if (hint >= (size_t)FT_ATOMIC_LOAD_SSIZE_RELAXED(dk->dk_nentries)) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); + if (dk->dk_kind != DICT_KEYS_UNICODE) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dk) + hint; + if (FT_ATOMIC_LOAD_PTR_RELAXED(ep->me_key) != name) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + attr_o = FT_ATOMIC_LOAD_PTR(ep->me_value); + if (attr_o == NULL) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + STAT_INC(LOAD_ATTR, hit); + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(&ep->me_value, attr_o, &attr); + if (!increfed) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + o = owner; + _tos_cache1 = o; + _tos_cache0 = attr; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_SLOT_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + owner = stack_pointer[-1]; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **addr = (PyObject **)((char *)owner_o + index); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR(*addr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(addr, attr_o, &attr); + if (!increfed) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache1 = o; + _tos_cache0 = attr; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_SLOT_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **addr = (PyObject **)((char *)owner_o + index); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR(*addr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(addr, attr_o, &attr); + if (!increfed) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache1 = o; + _tos_cache0 = attr; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_SLOT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **addr = (PyObject **)((char *)owner_o + index); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR(*addr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(addr, attr_o, &attr); + if (!increfed) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache2 = o; + _tos_cache1 = attr; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_SLOT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **addr = (PyObject **)((char *)owner_o + index); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR(*addr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(addr, attr_o, &attr); + if (!increfed) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache3 = o; + _tos_cache2 = attr; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_SLOT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + PyObject **addr = (PyObject **)((char *)owner_o + index); + PyObject *attr_o = FT_ATOMIC_LOAD_PTR(*addr); + if (attr_o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + #ifdef Py_GIL_DISABLED + int increfed = _Py_TryIncrefCompareStackRef(addr, attr_o, &attr); + if (!increfed) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + #else + attr = PyStackRef_FromPyObjectNew(attr_o); + #endif + STAT_INC(LOAD_ATTR, hit); + o = owner; + _tos_cache4 = o; + _tos_cache3 = attr; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_ATTR_CLASS_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + owner = stack_pointer[-1]; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!PyType_Check(owner_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_ATTR_CLASS_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!PyType_Check(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_ATTR_CLASS_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!PyType_Check(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_ATTR_CLASS_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!PyType_Check(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_ATTR_CLASS_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!PyType_Check(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_ATTR_CLASS_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + owner = _stack_item_4; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!PyType_Check(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + assert(type_version != 0); + if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_CLASS_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + attr = PyStackRef_FromPyObjectNew(descr); + stack_pointer[0] = owner; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp = owner; + owner = attr; + stack_pointer[-1] = owner; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache0 = attr; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_PROPERTY_FRAME_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef new_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + owner = _stack_item_0; + PyObject *fget = (PyObject *)CURRENT_OPERAND0_64(); + assert((oparg & 1) == 0); + assert(Py_IS_TYPE(fget, &PyFunction_Type)); + PyFunctionObject *f = (PyFunctionObject *)fget; + PyCodeObject *code = (PyCodeObject *)f->func_code; + if ((code->co_flags & (CO_VARKEYWORDS | CO_VARARGS | CO_OPTIMIZED)) != CO_OPTIMIZED) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + if (code->co_kwonlyargcount) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + if (code->co_argcount != 1) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(LOAD_ATTR, hit); + _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, PyStackRef_FromPyObjectNew(fget), 1, frame); + pushed_frame->localsplus[0] = owner; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN is not a viable micro-op for tier 2 because it has too many cache entries */ + + case _GUARD_DORV_NO_DICT_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + owner = stack_pointer[-1]; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (_PyObject_GetManagedDict(owner_o) || + !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_DORV_NO_DICT_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + owner = _stack_item_0; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (_PyObject_GetManagedDict(owner_o) || + !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_DORV_NO_DICT_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (_PyObject_GetManagedDict(owner_o) || + !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_DORV_NO_DICT_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (_PyObject_GetManagedDict(owner_o) || + !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_DORV_NO_DICT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (_PyObject_GetManagedDict(owner_o) || + !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_DORV_NO_DICT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + owner = _stack_item_4; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_dictoffset < 0); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + if (_PyObject_GetManagedDict(owner_o) || + !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + UNLOCK_OBJECT(owner_o); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_ATTR_INSTANCE_VALUE_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + value = _stack_item_0; + uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + STAT_INC(STORE_ATTR, hit); + assert(_PyObject_GetManagedDict(owner_o) == NULL); + PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); + PyObject *old_value = *value_ptr; + FT_ATOMIC_STORE_PTR_RELEASE(*value_ptr, PyStackRef_AsPyObjectSteal(value)); + if (old_value == NULL) { + PyDictValues *values = _PyObject_InlineValues(owner_o); + Py_ssize_t index = value_ptr - values->values; + _PyDictValues_AddToInsertionOrder(values, index); + } + UNLOCK_OBJECT(owner_o); + o = owner; + stack_pointer[0] = o; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_XDECREF(old_value); + stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache0 = o; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_ATTR_WITH_HINT_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + owner = _stack_item_1; + value = _stack_item_0; + uint16_t hint = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_MANAGED_DICT); + PyDictObject *dict = _PyObject_GetManagedDict(owner_o); + if (dict == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + if (!LOCK_OBJECT(dict)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + assert(PyDict_CheckExact((PyObject *)dict)); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + if (hint >= (size_t)dict->ma_keys->dk_nentries || + dict->ma_keys->dk_kind != DICT_KEYS_UNICODE) { + UNLOCK_OBJECT(dict); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + } + PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint; + if (ep->me_key != name) { + UNLOCK_OBJECT(dict); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + } + PyObject *old_value = ep->me_value; + if (old_value == NULL) { + UNLOCK_OBJECT(dict); + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + } + stack_pointer[0] = value; + stack_pointer[1] = owner; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyDict_NotifyEvent(PyDict_EVENT_MODIFIED, dict, name, PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); + FT_ATOMIC_STORE_PTR_RELEASE(ep->me_value, PyStackRef_AsPyObjectSteal(value)); + UNLOCK_OBJECT(dict); + STAT_INC(STORE_ATTR, hit); + o = owner; + stack_pointer[-2] = o; + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_XDECREF(old_value); + stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache0 = o; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _STORE_ATTR_SLOT_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef value; + _PyStackRef o; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + owner = _stack_item_1; + value = _stack_item_0; + uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + if (!LOCK_OBJECT(owner_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + char *addr = (char *)owner_o + index; + STAT_INC(STORE_ATTR, hit); + PyObject *old_value = *(PyObject **)addr; + FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value)); + UNLOCK_OBJECT(owner_o); + o = owner; + stack_pointer[0] = o; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_XDECREF(old_value); + stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache0 = o; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COMPARE_OP_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert((oparg >> 5) <= Py_GE); + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); + _PyStackRef tmp = right; + right = PyStackRef_NULL; + stack_pointer[-1] = right; + PyStackRef_CLOSE(tmp); + tmp = left; + left = PyStackRef_NULL; + stack_pointer[-2] = left; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (oparg & 16) { + _PyFrame_SetStackPointer(frame, stack_pointer); + int res_bool = PyObject_IsTrue(res_o); + Py_DECREF(res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_bool < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = res_bool ? PyStackRef_True : PyStackRef_False; + } + else { + res = PyStackRef_FromPyObjectSteal(res_o); + } + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COMPARE_OP_FLOAT_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + oparg = CURRENT_OPARG(); + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + STAT_INC(COMPARE_OP, hit); + double dleft = PyFloat_AS_DOUBLE(left_o); + double dright = PyFloat_AS_DOUBLE(right_o); + int sign_ish = COMPARISON_BIT(dleft, dright); + l = left; + r = right; + res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COMPARE_OP_FLOAT_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + STAT_INC(COMPARE_OP, hit); + double dleft = PyFloat_AS_DOUBLE(left_o); + double dright = PyFloat_AS_DOUBLE(right_o); + int sign_ish = COMPARISON_BIT(dleft, dright); + l = left; + r = right; + res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COMPARE_OP_FLOAT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + STAT_INC(COMPARE_OP, hit); + double dleft = PyFloat_AS_DOUBLE(left_o); + double dright = PyFloat_AS_DOUBLE(right_o); + int sign_ish = COMPARISON_BIT(dleft, dright); + l = left; + r = right; + res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COMPARE_OP_FLOAT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + right = _stack_item_2; + left = _stack_item_1; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + STAT_INC(COMPARE_OP, hit); + double dleft = PyFloat_AS_DOUBLE(left_o); + double dright = PyFloat_AS_DOUBLE(right_o); + int sign_ish = COMPARISON_BIT(dleft, dright); + l = left; + r = right; + res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COMPARE_OP_FLOAT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + right = _stack_item_3; + left = _stack_item_2; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + STAT_INC(COMPARE_OP, hit); + double dleft = PyFloat_AS_DOUBLE(left_o); + double dright = PyFloat_AS_DOUBLE(right_o); + int sign_ish = COMPARISON_BIT(dleft, dright); + l = left; + r = right; + res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COMPARE_OP_INT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(_PyLong_IsCompact((PyLongObject *)left_o)); + assert(_PyLong_IsCompact((PyLongObject *)right_o)); + STAT_INC(COMPARE_OP, hit); + assert(_PyLong_DigitCount((PyLongObject *)left_o) <= 1 && + _PyLong_DigitCount((PyLongObject *)right_o) <= 1); + Py_ssize_t ileft = _PyLong_CompactValue((PyLongObject *)left_o); + Py_ssize_t iright = _PyLong_CompactValue((PyLongObject *)right_o); + int sign_ish = COMPARISON_BIT(ileft, iright); + l = left; + r = right; + res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COMPARE_OP_STR_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + STAT_INC(COMPARE_OP, hit); + int eq = _PyUnicode_Equal(left_o, right_o); + assert((oparg >> 5) == Py_EQ || (oparg >> 5) == Py_NE); + l = left; + r = right; + assert(eq == 0 || eq == 1); + assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); + assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); + res = ((COMPARISON_NOT_EQUALS + eq) & oparg) ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _IS_OP_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef l; + _PyStackRef r; + oparg = CURRENT_OPARG(); + right = stack_pointer[-1]; + left = stack_pointer[-2]; + int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg; + b = res ? PyStackRef_True : PyStackRef_False; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = b; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _IS_OP_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + right = _stack_item_0; + left = stack_pointer[-1]; + int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg; + b = res ? PyStackRef_True : PyStackRef_False; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = b; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _IS_OP_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + right = _stack_item_1; + left = _stack_item_0; + int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg; + b = res ? PyStackRef_True : PyStackRef_False; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = b; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _IS_OP_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + right = _stack_item_2; + left = _stack_item_1; + int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg; + b = res ? PyStackRef_True : PyStackRef_False; + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = b; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _IS_OP_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + right = _stack_item_3; + left = _stack_item_2; + int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg; + b = res ? PyStackRef_True : PyStackRef_False; + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = b; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CONTAINS_OP_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int res = PySequence_Contains(right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = b; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_SET_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + tos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_SET_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + tos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_SET_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + tos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_SET_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + tos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_SET_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_ANY_SET_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyAnySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_SET_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + tos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_SET_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + tos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_SET_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + tos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_SET_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + tos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_SET_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_SET_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PySet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENSET_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + tos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenSet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENSET_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + tos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenSet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = tos; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENSET_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + tos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenSet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = tos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENSET_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + tos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenSet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = tos; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENSET_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + tos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenSet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = tos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_TOS_FROZENSET_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef tos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + tos = _stack_item_4; + PyObject *o = PyStackRef_AsPyObjectBorrow(tos); + if (!PyFrozenSet_CheckExact(o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = tos; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CONTAINS_OP_SET_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyAnySet_CheckExact(right_o)); + STAT_INC(CONTAINS_OP, hit); + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int res = _PySet_Contains((PySetObject *)right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = b; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CONTAINS_OP_DICT_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyAnyDict_CheckExact(right_o)); + STAT_INC(CONTAINS_OP, hit); + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int res = PyDict_Contains(right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = b; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_EG_MATCH_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef match_type_st; + _PyStackRef exc_value_st; + _PyStackRef rest; + _PyStackRef match; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + match_type_st = _stack_item_1; + exc_value_st = _stack_item_0; + PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); + PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); + stack_pointer[0] = exc_value_st; + stack_pointer[1] = match_type_st; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp = match_type_st; + match_type_st = PyStackRef_NULL; + stack_pointer[-1] = match_type_st; + PyStackRef_CLOSE(tmp); + tmp = exc_value_st; + exc_value_st = PyStackRef_NULL; + stack_pointer[-2] = exc_value_st; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + PyObject *match_o = NULL; + PyObject *rest_o = NULL; + _PyFrame_SetStackPointer(frame, stack_pointer); + int res = _PyEval_ExceptionGroupMatch(frame, exc_value, match_type, + &match_o, &rest_o); + _PyStackRef tmp = match_type_st; + match_type_st = PyStackRef_NULL; + stack_pointer[-1] = match_type_st; + PyStackRef_CLOSE(tmp); + tmp = exc_value_st; + exc_value_st = PyStackRef_NULL; + stack_pointer[-2] = exc_value_st; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (res < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + assert((match_o == NULL) == (rest_o == NULL)); + if (match_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (!Py_IsNone(match_o)) { + _PyFrame_SetStackPointer(frame, stack_pointer); + PyErr_SetHandledException(match_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + rest = PyStackRef_FromPyObjectSteal(rest_o); + match = PyStackRef_FromPyObjectSteal(match_o); + _tos_cache1 = match; + _tos_cache0 = rest; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_EXC_MATCH_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef b; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + right = _stack_item_1; + left = _stack_item_0; + PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + assert(PyExceptionInstance_Check(left_o)); + stack_pointer[0] = left; + stack_pointer[1] = right; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _PyEval_CheckExceptTypeValid(tstate, right_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + int res = PyErr_GivenExceptionMatches(left_o, right_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(right); + stack_pointer = _PyFrame_GetStackPointer(frame); + b = res ? PyStackRef_True : PyStackRef_False; + _tos_cache1 = b; + _tos_cache0 = left; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _IMPORT_NAME_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef fromlist; + _PyStackRef level; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + fromlist = _stack_item_1; + level = _stack_item_0; + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + PyObject *res_o; + if (!(oparg & 0x02)) { + stack_pointer[0] = level; + stack_pointer[1] = fromlist; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = _PyEval_LazyImportName(tstate, BUILTINS(), GLOBALS(), + LOCALS(), name, + PyStackRef_AsPyObjectBorrow(fromlist), + PyStackRef_AsPyObjectBorrow(level), + oparg & 0x01); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else { + stack_pointer[0] = level; + stack_pointer[1] = fromlist; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = _PyEval_ImportName(tstate, BUILTINS(), GLOBALS(), + LOCALS(), name, + PyStackRef_AsPyObjectBorrow(fromlist), + PyStackRef_AsPyObjectBorrow(level)); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp = fromlist; + fromlist = PyStackRef_NULL; + stack_pointer[-1] = fromlist; + PyStackRef_CLOSE(tmp); + tmp = level; + level = PyStackRef_NULL; + stack_pointer[-2] = level; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _IMPORT_FROM_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef from; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + from = _stack_item_0; + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *res_o; + if (PyLazyImport_CheckExact(PyStackRef_AsPyObjectBorrow(from))) { + stack_pointer[0] = from; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = _PyEval_LazyImportFrom( + tstate, frame, PyStackRef_AsPyObjectBorrow(from), name); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + else { + stack_pointer[0] = from; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = _PyEval_ImportFrom( + tstate, PyStackRef_AsPyObjectBorrow(from), name); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + if (res_o == NULL) { + stack_pointer[-1] = from; + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache1 = res; + _tos_cache0 = from; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _POP_JUMP_IF_FALSE is not a viable micro-op for tier 2 because it is replaced */ + + /* _POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 because it is replaced */ + + case _IS_NONE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef b; + _PyStackRef _stack_item_0 = _tos_cache0; + value = _stack_item_0; + if (PyStackRef_IsNone(value)) { + b = PyStackRef_True; + } + else { + b = PyStackRef_False; + stack_pointer[0] = value; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp = value; + value = b; + stack_pointer[-1] = value; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + } + _tos_cache0 = b; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _JUMP_BACKWARD_NO_INTERRUPT is not a viable micro-op for tier 2 because it is replaced */ + + case _GET_LEN_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef obj; + _PyStackRef len; + _PyStackRef _stack_item_0 = _tos_cache0; + obj = _stack_item_0; + stack_pointer[0] = obj; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (len_i < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + PyObject *len_o = PyLong_FromSsize_t(len_i); + if (len_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + len = PyStackRef_FromPyObjectSteal(len_o); + _tos_cache1 = len; + _tos_cache0 = obj; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_CLASS_r31: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef names; + _PyStackRef type; + _PyStackRef subject; + _PyStackRef attrs; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + names = _stack_item_2; + type = _stack_item_1; + subject = _stack_item_0; + assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); + stack_pointer[0] = subject; + stack_pointer[1] = type; + stack_pointer[2] = names; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *attrs_o = _PyEval_MatchClass(tstate, + PyStackRef_AsPyObjectBorrow(subject), + PyStackRef_AsPyObjectBorrow(type), oparg, + PyStackRef_AsPyObjectBorrow(names)); + _PyStackRef tmp = names; + names = PyStackRef_NULL; + stack_pointer[-1] = names; + PyStackRef_CLOSE(tmp); + tmp = type; + type = PyStackRef_NULL; + stack_pointer[-2] = type; + PyStackRef_CLOSE(tmp); + tmp = subject; + subject = PyStackRef_NULL; + stack_pointer[-3] = subject; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (attrs_o) { + assert(PyTuple_CheckExact(attrs_o)); + attrs = PyStackRef_FromPyObjectSteal(attrs_o); + } + else { + if (_PyErr_Occurred(tstate)) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + attrs = PyStackRef_None; + } + _tos_cache0 = attrs; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_MAPPING_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + subject = stack_pointer[-1]; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache1 = res; + _tos_cache0 = subject; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_MAPPING_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + subject = _stack_item_0; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache1 = res; + _tos_cache0 = subject; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_MAPPING_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + subject = _stack_item_1; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = res; + _tos_cache1 = subject; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_MAPPING_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + subject = _stack_item_2; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache3 = res; + _tos_cache2 = subject; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_MAPPING_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + subject = _stack_item_3; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache4 = res; + _tos_cache3 = subject; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_SEQUENCE_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + subject = stack_pointer[-1]; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache1 = res; + _tos_cache0 = subject; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_SEQUENCE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + subject = _stack_item_0; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache1 = res; + _tos_cache0 = subject; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_SEQUENCE_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + subject = _stack_item_1; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache2 = res; + _tos_cache1 = subject; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_SEQUENCE_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + subject = _stack_item_2; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache3 = res; + _tos_cache2 = subject; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_SEQUENCE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef subject; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + subject = _stack_item_3; + int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; + res = match ? PyStackRef_True : PyStackRef_False; + _tos_cache4 = res; + _tos_cache3 = subject; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MATCH_KEYS_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef keys; + _PyStackRef subject; + _PyStackRef values_or_none; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + keys = _stack_item_1; + subject = _stack_item_0; + stack_pointer[0] = subject; + stack_pointer[1] = keys; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, + PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (values_or_none_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); + _tos_cache2 = values_or_none; + _tos_cache1 = keys; + _tos_cache0 = subject; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GET_ITER_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iterable; + _PyStackRef iter; + _PyStackRef index_or_null; + _PyStackRef _stack_item_0 = _tos_cache0; + iterable = _stack_item_0; + #ifdef Py_STATS + stack_pointer[0] = iterable; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _Py_GatherStats_GetIter(iterable); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + #endif + PyTypeObject *tp = PyStackRef_TYPE(iterable); + if (tp == &PyTuple_Type || tp == &PyList_Type) { + iter = iterable; + index_or_null = PyStackRef_TagInt(0); + } + else { + stack_pointer[0] = iterable; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *iter_o = PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable)); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(iterable); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (iter_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + iter = PyStackRef_FromPyObjectSteal(iter_o); + index_or_null = PyStackRef_NULL; + } + _tos_cache1 = index_or_null; + _tos_cache0 = iter; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GET_YIELD_FROM_ITER_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iterable; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + iterable = _stack_item_0; + PyObject *iterable_o = PyStackRef_AsPyObjectBorrow(iterable); + if (PyCoro_CheckExact(iterable_o)) { + if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { + stack_pointer[0] = iterable; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_SetString(tstate, PyExc_TypeError, + "cannot 'yield from' a coroutine object " + "in a non-coroutine generator"); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + iter = iterable; + } + else if (PyGen_CheckExact(iterable_o)) { + iter = iterable; + } + else { + stack_pointer[0] = iterable; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *iter_o = PyObject_GetIter(iterable_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (iter_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + iter = PyStackRef_FromPyObjectSteal(iter_o); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef tmp = iterable; + iterable = iter; + stack_pointer[-1] = iterable; + PyStackRef_CLOSE(tmp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + } + _tos_cache0 = iter; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _FOR_ITER is not a viable micro-op for tier 2 because it is replaced */ + + case _FOR_ITER_TIER_TWO_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef next; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null_or_index = _stack_item_1; + iter = _stack_item_0; + stack_pointer[0] = iter; + stack_pointer[1] = null_or_index; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, iter, &null_or_index); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (!PyStackRef_IsValid(item)) { + if (PyStackRef_IsError(item)) { + stack_pointer[-1] = null_or_index; + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + } + next = item; + _tos_cache2 = next; + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 because it is instrumented */ + + case _ITER_CHECK_LIST_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + null_or_index = stack_pointer[-1]; + iter = stack_pointer[-2]; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyList_Type) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + #ifdef Py_GIL_DISABLED + if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_LIST_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + null_or_index = _stack_item_0; + iter = stack_pointer[-1]; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyList_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = null_or_index; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + #ifdef Py_GIL_DISABLED + if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = null_or_index; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_LIST_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null_or_index = _stack_item_1; + iter = _stack_item_0; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyList_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + #ifdef Py_GIL_DISABLED + if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_LIST_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + null_or_index = _stack_item_2; + iter = _stack_item_1; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyList_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + #ifdef Py_GIL_DISABLED + if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_LIST_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + null_or_index = _stack_item_3; + iter = _stack_item_2; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyList_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + #ifdef Py_GIL_DISABLED + if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_LIST_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + null_or_index = _stack_item_4; + iter = _stack_item_3; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyList_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + #ifdef Py_GIL_DISABLED + if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 because it is replaced */ + + case _GUARD_NOT_EXHAUSTED_LIST_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + null_or_index = stack_pointer[-1]; + iter = stack_pointer[-2]; + #ifndef Py_GIL_DISABLED + PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(list_o) == &PyList_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_LIST_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + null_or_index = _stack_item_0; + iter = stack_pointer[-1]; + #ifndef Py_GIL_DISABLED + PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(list_o) == &PyList_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = null_or_index; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_LIST_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null_or_index = _stack_item_1; + iter = _stack_item_0; + #ifndef Py_GIL_DISABLED + PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(list_o) == &PyList_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_LIST_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + null_or_index = _stack_item_2; + iter = _stack_item_1; + #ifndef Py_GIL_DISABLED + PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(list_o) == &PyList_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_LIST_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + null_or_index = _stack_item_3; + iter = _stack_item_2; + #ifndef Py_GIL_DISABLED + PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(list_o) == &PyList_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_LIST_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + null_or_index = _stack_item_4; + iter = _stack_item_3; + #ifndef Py_GIL_DISABLED + PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(list_o) == &PyList_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _ITER_NEXT_LIST is not a viable micro-op for tier 2 because it is replaced */ + + case _ITER_NEXT_LIST_TIER_TWO_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef next; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null_or_index = _stack_item_1; + iter = _stack_item_0; + PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); + assert(PyList_CheckExact(list_o)); + #ifdef Py_GIL_DISABLED + assert(_Py_IsOwnedByCurrentThread((PyObject *)list_o) || + _PyObject_GC_IS_SHARED(list_o)); + STAT_INC(FOR_ITER, hit); + stack_pointer[0] = iter; + stack_pointer[1] = null_or_index; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int result = _PyList_GetItemRefNoLock((PyListObject *)list_o, PyStackRef_UntagInt(null_or_index), &next); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (result <= 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + #else + assert(PyStackRef_UntagInt(null_or_index) < PyList_GET_SIZE(list_o)); + next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(list_o, PyStackRef_UntagInt(null_or_index))); + stack_pointer += 2; + #endif + null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); + _tos_cache2 = next; + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_TUPLE_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + null_or_index = stack_pointer[-1]; + iter = stack_pointer[-2]; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyTuple_Type) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_TUPLE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + null_or_index = _stack_item_0; + iter = stack_pointer[-1]; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyTuple_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = null_or_index; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_TUPLE_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null_or_index = _stack_item_1; + iter = _stack_item_0; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyTuple_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_TUPLE_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - self_st = _stack_item_2; - class_st = _stack_item_1; - global_super_st = _stack_item_0; - PyObject *global_super = PyStackRef_AsPyObjectBorrow(global_super_st); - PyObject *class = PyStackRef_AsPyObjectBorrow(class_st); - PyObject *self = PyStackRef_AsPyObjectBorrow(self_st); - assert(!(oparg & 1)); - if (global_super != (PyObject *)&PySuper_Type) { + null_or_index = _stack_item_2; + iter = _stack_item_1; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyTuple_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = self_st; - _tos_cache1 = class_st; - _tos_cache0 = global_super_st; + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - if (!PyType_Check(class)) { + assert(PyStackRef_IsTaggedInt(null_or_index)); + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_TUPLE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + null_or_index = _stack_item_3; + iter = _stack_item_2; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyTuple_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = self_st; - _tos_cache1 = class_st; - _tos_cache0 = global_super_st; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - STAT_INC(LOAD_SUPER_ATTR, hit); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); - stack_pointer[0] = global_super_st; - stack_pointer[1] = class_st; - stack_pointer[2] = self_st; - stack_pointer += 3; + assert(PyStackRef_IsTaggedInt(null_or_index)); + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_CHECK_TUPLE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + null_or_index = _stack_item_4; + iter = _stack_item_3; + PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(iter_o) != &PyTuple_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + assert(PyStackRef_IsTaggedInt(null_or_index)); + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + /* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 because it is replaced */ + + case _GUARD_NOT_EXHAUSTED_TUPLE_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + null_or_index = stack_pointer[-1]; + iter = stack_pointer[-2]; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); - _PyStackRef tmp = self_st; - self_st = PyStackRef_NULL; - stack_pointer[-1] = self_st; - PyStackRef_CLOSE(tmp); - tmp = class_st; - class_st = PyStackRef_NULL; - stack_pointer[-2] = class_st; - PyStackRef_CLOSE(tmp); - tmp = global_super_st; - global_super_st = PyStackRef_NULL; - stack_pointer[-3] = global_super_st; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_TUPLE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + null_or_index = _stack_item_0; + iter = stack_pointer[-1]; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = null_or_index; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (attr == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_TUPLE_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null_or_index = _stack_item_1; + iter = _stack_item_0; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); } - attr_st = PyStackRef_FromPyObjectSteal(attr); - _tos_cache0 = attr_st; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_TUPLE_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + null_or_index = _stack_item_2; + iter = _stack_item_1; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SUPER_ATTR_METHOD_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_NOT_EXHAUSTED_TUPLE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self_st; - _PyStackRef class_st; - _PyStackRef global_super_st; - _PyStackRef attr; - _PyStackRef self_or_null; + _PyStackRef null_or_index; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - self_st = _stack_item_2; - class_st = _stack_item_1; - global_super_st = _stack_item_0; - PyObject *global_super = PyStackRef_AsPyObjectBorrow(global_super_st); - PyObject *class = PyStackRef_AsPyObjectBorrow(class_st); - PyObject *self = PyStackRef_AsPyObjectBorrow(self_st); - assert(oparg & 1); - if (global_super != (PyObject *)&PySuper_Type) { + _PyStackRef _stack_item_3 = _tos_cache3; + null_or_index = _stack_item_3; + iter = _stack_item_2; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = self_st; - _tos_cache1 = class_st; - _tos_cache0 = global_super_st; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - if (!PyType_Check(class)) { + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOT_EXHAUSTED_TUPLE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + null_or_index = _stack_item_4; + iter = _stack_item_3; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = self_st; - _tos_cache1 = class_st; - _tos_cache0 = global_super_st; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - STAT_INC(LOAD_SUPER_ATTR, hit); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); - PyTypeObject *cls = (PyTypeObject *)class; - int method_found = 0; - PyObject *attr_o; - { - int *method_found_ptr = &method_found; - stack_pointer[0] = global_super_st; - stack_pointer[1] = class_st; - stack_pointer[2] = self_st; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - attr_o = _PySuper_Lookup(cls, self, name, - Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? method_found_ptr : NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - if (attr_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (method_found) { - self_or_null = self_st; - } else { - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(self_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - self_or_null = PyStackRef_NULL; - stack_pointer += 1; - } - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp = global_super_st; - global_super_st = self_or_null; - stack_pointer[-2] = global_super_st; - PyStackRef_CLOSE(tmp); - tmp = class_st; - class_st = PyStackRef_NULL; - stack_pointer[-1] = class_st; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache4 = null_or_index; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_NEXT_TUPLE_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef next; + null_or_index = stack_pointer[-1]; + iter = stack_pointer[-2]; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + uintptr_t i = PyStackRef_UntagInt(null_or_index); + assert((size_t)i < (size_t)PyTuple_GET_SIZE(tuple_o)); + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(tuple_o, i)); + null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); + _tos_cache2 = next; + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(3); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - attr = PyStackRef_FromPyObjectSteal(attr_o); - _tos_cache1 = self_or_null; - _tos_cache0 = attr; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_r10: { + case _ITER_NEXT_TUPLE_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef *self_or_null; + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef next; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - owner = _stack_item_0; - self_or_null = &stack_pointer[1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 1); - if (oparg & 1) { - stack_pointer[0] = owner; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - attr = _Py_LoadAttr_StackRefSteal(tstate, owner, name, self_or_null); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(attr)) { - stack_pointer[-1] = attr; - stack_pointer += (oparg&1); - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - } - else { - stack_pointer[0] = owner; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - attr = _PyObject_GetAttrStackRef(PyStackRef_AsPyObjectBorrow(owner), name); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer[-1] = attr; - stack_pointer += (oparg&1); - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(owner); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(attr)) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - stack_pointer += -(oparg&1); - } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[-1] = attr; - stack_pointer += (oparg&1); + null_or_index = _stack_item_0; + iter = stack_pointer[-1]; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + uintptr_t i = PyStackRef_UntagInt(null_or_index); + assert((size_t)i < (size_t)PyTuple_GET_SIZE(tuple_o)); + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(tuple_o, i)); + null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); + _tos_cache2 = next; + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_NEXT_TUPLE_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef next; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null_or_index = _stack_item_1; + iter = _stack_item_0; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + uintptr_t i = PyStackRef_UntagInt(null_or_index); + assert((size_t)i < (size_t)PyTuple_GET_SIZE(tuple_o)); + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(tuple_o, i)); + null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); + _tos_cache2 = next; + _tos_cache1 = null_or_index; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_NEXT_TUPLE_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef next; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + null_or_index = _stack_item_2; + iter = _stack_item_1; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + uintptr_t i = PyStackRef_UntagInt(null_or_index); + assert((size_t)i < (size_t)PyTuple_GET_SIZE(tuple_o)); + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(tuple_o, i)); + null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); + _tos_cache3 = next; + _tos_cache2 = null_or_index; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_NEXT_TUPLE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null_or_index; + _PyStackRef iter; + _PyStackRef next; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + null_or_index = _stack_item_3; + iter = _stack_item_2; + PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(tuple_o) == &PyTuple_Type); + uintptr_t i = PyStackRef_UntagInt(null_or_index); + assert((size_t)i < (size_t)PyTuple_GET_SIZE(tuple_o)); + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(tuple_o, i)); + null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); + _tos_cache4 = next; + _tos_cache3 = null_or_index; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TYPE_VERSION_r01: { + case _ITER_CHECK_RANGE_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - owner = stack_pointer[-1]; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); - assert(type_version != 0); - if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + _PyStackRef iter; + iter = stack_pointer[-2]; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(r) != &PyRangeIter_Type) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; + #ifdef Py_GIL_DISABLED + if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TYPE_VERSION_r11: { + case _ITER_CHECK_RANGE_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); - assert(type_version != 0); - if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + iter = stack_pointer[-1]; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(r) != &PyRangeIter_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + #ifdef Py_GIL_DISABLED + if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = _stack_item_0; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TYPE_VERSION_r22: { + case _ITER_CHECK_RANGE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); - assert(type_version != 0); - if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + iter = _stack_item_0; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(r) != &PyRangeIter_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; + #ifdef Py_GIL_DISABLED + if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + #endif + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TYPE_VERSION_r33: { + case _ITER_CHECK_RANGE_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - owner = _stack_item_2; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); - assert(type_version != 0); - if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { + iter = _stack_item_1; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(r) != &PyRangeIter_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TYPE_VERSION_AND_LOCK_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - owner = stack_pointer[-1]; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(type_version != 0); - if (!LOCK_OBJECT(owner_o)) { + #ifdef Py_GIL_DISABLED + if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - PyTypeObject *tp = Py_TYPE(owner_o); - if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { - UNLOCK_OBJECT(owner_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + #endif + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TYPE_VERSION_AND_LOCK_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _ITER_CHECK_RANGE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(type_version != 0); - if (!LOCK_OBJECT(owner_o)) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + iter = _stack_item_2; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(r) != &PyRangeIter_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - PyTypeObject *tp = Py_TYPE(owner_o); - if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { - UNLOCK_OBJECT(owner_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TYPE_VERSION_AND_LOCK_r22: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(type_version != 0); - if (!LOCK_OBJECT(owner_o)) { + #ifdef Py_GIL_DISABLED + if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - PyTypeObject *tp = Py_TYPE(owner_o); - if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { - UNLOCK_OBJECT(owner_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - } - _tos_cache1 = owner; + #endif + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TYPE_VERSION_AND_LOCK_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _ITER_CHECK_RANGE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - owner = _stack_item_2; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(type_version != 0); - if (!LOCK_OBJECT(owner_o)) { + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + iter = _stack_item_3; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(r) != &PyRangeIter_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; + _tos_cache4 = _stack_item_4; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - PyTypeObject *tp = Py_TYPE(owner_o); - if (FT_ATOMIC_LOAD_UINT_RELAXED(tp->tp_version_tag) != type_version) { - UNLOCK_OBJECT(owner_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + #ifdef Py_GIL_DISABLED + if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = owner; + #endif + _tos_cache4 = _stack_item_4; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_MANAGED_OBJECT_HAS_VALUES_r01: { + /* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 because it is replaced */ + + case _GUARD_NOT_EXHAUSTED_RANGE_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - owner = stack_pointer[-1]; - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_dictoffset < 0); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + _PyStackRef iter; + iter = stack_pointer[-2]; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); + if (r->len <= 0) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_MANAGED_OBJECT_HAS_VALUES_r11: { + case _GUARD_NOT_EXHAUSTED_RANGE_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_dictoffset < 0); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + iter = stack_pointer[-1]; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); + if (r->len <= 0) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache1 = _stack_item_0; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_MANAGED_OBJECT_HAS_VALUES_r22: { + case _GUARD_NOT_EXHAUSTED_RANGE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_dictoffset < 0); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + iter = _stack_item_0; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); + if (r->len <= 0) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_MANAGED_OBJECT_HAS_VALUES_r33: { + case _GUARD_NOT_EXHAUSTED_RANGE_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - owner = _stack_item_2; - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_dictoffset < 0); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - if (!FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { + iter = _stack_item_1; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); + if (r->len <= 0) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_INSTANCE_VALUE_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_NOT_EXHAUSTED_RANGE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef o; - owner = stack_pointer[-1]; - uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); - PyObject *attr_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(*value_ptr); - if (attr_o == NULL) { + _PyStackRef iter; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + iter = _stack_item_2; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); + if (r->len <= 0) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - #ifdef Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(value_ptr, attr_o, &attr); - if (!increfed) { - if (true) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - } - #else - attr = PyStackRef_FromPyObjectNew(attr_o); - #endif - STAT_INC(LOAD_ATTR, hit); - o = owner; - _tos_cache1 = o; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_INSTANCE_VALUE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_NOT_EXHAUSTED_RANGE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef o; + _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); - PyObject *attr_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(*value_ptr); - if (attr_o == NULL) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + iter = _stack_item_3; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); + if (r->len <= 0) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache4 = _stack_item_4; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } + _tos_cache4 = _stack_item_4; + _tos_cache3 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _ITER_NEXT_RANGE_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iter; + _PyStackRef next; + iter = stack_pointer[-2]; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); #ifdef Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(value_ptr, attr_o, &attr); - if (!increfed) { - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + assert(_PyObject_IsUniquelyReferenced((PyObject *)r)); + #endif + assert(r->len > 0); + long value = r->start; + r->start = value + r->step; + r->len--; + PyObject *res = PyLong_FromLong(value); + if (res == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } + next = PyStackRef_FromPyObjectSteal(res); + _tos_cache2 = next; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; #else - attr = PyStackRef_FromPyObjectNew(attr_o); + Py_UNREACHABLE(); #endif - STAT_INC(LOAD_ATTR, hit); - o = owner; - _tos_cache1 = o; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); + } + + case _ITER_NEXT_RANGE_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iter; + _PyStackRef next; + _PyStackRef _stack_item_0 = _tos_cache0; + iter = stack_pointer[-1]; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); + #ifdef Py_GIL_DISABLED + assert(_PyObject_IsUniquelyReferenced((PyObject *)r)); + #endif + assert(r->len > 0); + long value = r->start; + r->start = value + r->step; + r->len--; + PyObject *res = PyLong_FromLong(value); + if (res == NULL) { + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + next = PyStackRef_FromPyObjectSteal(res); + _tos_cache2 = next; + _tos_cache1 = _stack_item_0; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_INSTANCE_VALUE_r23: { + case _ITER_NEXT_RANGE_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef o; + _PyStackRef iter; + _PyStackRef next; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); - PyObject *attr_o = FT_ATOMIC_LOAD_PTR_ACQUIRE(*value_ptr); - if (attr_o == NULL) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + iter = _stack_item_0; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); #ifdef Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(value_ptr, attr_o, &attr); - if (!increfed) { - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - } - #else - attr = PyStackRef_FromPyObjectNew(attr_o); + assert(_PyObject_IsUniquelyReferenced((PyObject *)r)); #endif - STAT_INC(LOAD_ATTR, hit); - o = owner; - _tos_cache2 = o; - _tos_cache1 = attr; - _tos_cache0 = _stack_item_0; + assert(r->len > 0); + long value = r->start; + r->start = value + r->step; + r->len--; + PyObject *res = PyLong_FromLong(value); + if (res == NULL) { + stack_pointer[0] = iter; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + next = PyStackRef_FromPyObjectSteal(res); + _tos_cache2 = next; + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_MODULE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _ITER_NEXT_RANGE_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef o; + _PyStackRef iter; + _PyStackRef next; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - uint32_t dict_version = (uint32_t)CURRENT_OPERAND0_32(); - uint16_t index = (uint16_t)CURRENT_OPERAND1_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - if (Py_TYPE(owner_o)->tp_getattro != PyModule_Type.tp_getattro) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner_o)->md_dict; - assert(dict != NULL); - PyDictKeysObject *keys = FT_ATOMIC_LOAD_PTR_ACQUIRE(dict->ma_keys); - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != dict_version) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - assert(keys->dk_kind == DICT_KEYS_UNICODE); - assert(index < FT_ATOMIC_LOAD_SSIZE_RELAXED(keys->dk_nentries)); - PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(keys) + index; - PyObject *attr_o = FT_ATOMIC_LOAD_PTR_RELAXED(ep->me_value); - if (attr_o == NULL) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + iter = _stack_item_1; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); #ifdef Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(&ep->me_value, attr_o, &attr); - if (!increfed) { - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - } - #else - attr = PyStackRef_FromPyObjectNew(attr_o); + assert(_PyObject_IsUniquelyReferenced((PyObject *)r)); #endif - STAT_INC(LOAD_ATTR, hit); - o = owner; - _tos_cache1 = o; - _tos_cache0 = attr; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); + assert(r->len > 0); + long value = r->start; + r->start = value + r->step; + r->len--; + PyObject *res = PyLong_FromLong(value); + if (res == NULL) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = iter; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + next = PyStackRef_FromPyObjectSteal(res); + _tos_cache3 = next; + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_WITH_HINT_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _ITER_NEXT_RANGE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef o; + _PyStackRef iter; + _PyStackRef next; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - owner = _stack_item_0; - uint16_t hint = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_MANAGED_DICT); - PyDictObject *dict = _PyObject_GetManagedDict(owner_o); - if (dict == NULL) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - PyDictKeysObject *dk = FT_ATOMIC_LOAD_PTR(dict->ma_keys); - assert(PyDict_CheckExact((PyObject *)dict)); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + iter = _stack_item_2; + _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); + assert(Py_TYPE(r) == &PyRangeIter_Type); #ifdef Py_GIL_DISABLED - if (!_Py_IsOwnedByCurrentThread((PyObject *)dict) && !_PyObject_GC_IS_SHARED(dict)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + assert(_PyObject_IsUniquelyReferenced((PyObject *)r)); #endif - PyObject *attr_o; - if (hint >= (size_t)FT_ATOMIC_LOAD_SSIZE_RELAXED(dk->dk_nentries)) { - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - } - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); - if (dk->dk_kind != DICT_KEYS_UNICODE) { - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - } - PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dk) + hint; - if (FT_ATOMIC_LOAD_PTR_RELAXED(ep->me_key) != name) { - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - } - attr_o = FT_ATOMIC_LOAD_PTR(ep->me_value); - if (attr_o == NULL) { - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - } - STAT_INC(LOAD_ATTR, hit); - #ifdef Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(&ep->me_value, attr_o, &attr); - if (!increfed) { - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + assert(r->len > 0); + long value = r->start; + r->start = value + r->step; + r->len--; + PyObject *res = PyLong_FromLong(value); + if (res == NULL) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = iter; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } - #else - attr = PyStackRef_FromPyObjectNew(attr_o); - #endif - o = owner; - _tos_cache1 = o; - _tos_cache0 = attr; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); + next = PyStackRef_FromPyObjectSteal(res); + _tos_cache4 = next; + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_SLOT_r02: { + case _FOR_ITER_GEN_FRAME_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef o; - owner = stack_pointer[-1]; - uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - PyObject **addr = (PyObject **)((char *)owner_o + index); - PyObject *attr_o = FT_ATOMIC_LOAD_PTR(*addr); - if (attr_o == NULL) { + _PyStackRef iter; + _PyStackRef gen_frame; + oparg = CURRENT_OPARG(); + iter = stack_pointer[-2]; + PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(gen) != &PyGen_Type) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - #ifdef Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(addr, attr_o, &attr); - if (!increfed) { + if (!gen_try_set_executing((PyGenObject *)gen)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - #else - attr = PyStackRef_FromPyObjectNew(attr_o); - #endif - STAT_INC(LOAD_ATTR, hit); - o = owner; - _tos_cache1 = o; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; + STAT_INC(FOR_ITER, hit); + _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; + _PyFrame_StackPush(pushed_frame, PyStackRef_None); + gen->gi_exc_state.previous_item = tstate->exc_info; + tstate->exc_info = &gen->gi_exc_state; + pushed_frame->previous = frame; + frame->return_offset = (uint16_t)( 2u + oparg); + gen_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache2 = gen_frame; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_SLOT_r12: { + case _FOR_ITER_GEN_FRAME_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef o; + _PyStackRef iter; + _PyStackRef gen_frame; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - PyObject **addr = (PyObject **)((char *)owner_o + index); - PyObject *attr_o = FT_ATOMIC_LOAD_PTR(*addr); - if (attr_o == NULL) { + oparg = CURRENT_OPARG(); + iter = stack_pointer[-1]; + PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(gen) != &PyGen_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - #ifdef Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(addr, attr_o, &attr); - if (!increfed) { + if (!gen_try_set_executing((PyGenObject *)gen)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } + STAT_INC(FOR_ITER, hit); + _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; + _PyFrame_StackPush(pushed_frame, PyStackRef_None); + gen->gi_exc_state.previous_item = tstate->exc_info; + tstate->exc_info = &gen->gi_exc_state; + pushed_frame->previous = frame; + frame->return_offset = (uint16_t)( 2u + oparg); + gen_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache2 = gen_frame; + _tos_cache1 = _stack_item_0; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; #else - attr = PyStackRef_FromPyObjectNew(attr_o); + Py_UNREACHABLE(); #endif - STAT_INC(LOAD_ATTR, hit); - o = owner; - _tos_cache1 = o; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); + } + + case _FOR_ITER_GEN_FRAME_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iter; + _PyStackRef gen_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + iter = _stack_item_0; + PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(gen) != &PyGen_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + if (!gen_try_set_executing((PyGenObject *)gen)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(FOR_ITER, hit); + _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; + _PyFrame_StackPush(pushed_frame, PyStackRef_None); + gen->gi_exc_state.previous_item = tstate->exc_info; + tstate->exc_info = &gen->gi_exc_state; + pushed_frame->previous = frame; + frame->return_offset = (uint16_t)( 2u + oparg); + gen_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache2 = gen_frame; + _tos_cache1 = _stack_item_1; + _tos_cache0 = iter; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_SLOT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _FOR_ITER_GEN_FRAME_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef o; + _PyStackRef iter; + _PyStackRef gen_frame; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - PyObject **addr = (PyObject **)((char *)owner_o + index); - PyObject *attr_o = FT_ATOMIC_LOAD_PTR(*addr); - if (attr_o == NULL) { + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + iter = _stack_item_1; + PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(gen) != &PyGen_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - #ifdef Py_GIL_DISABLED - int increfed = _Py_TryIncrefCompareStackRef(addr, attr_o, &attr); - if (!increfed) { + if (!gen_try_set_executing((PyGenObject *)gen)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } + STAT_INC(FOR_ITER, hit); + _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; + _PyFrame_StackPush(pushed_frame, PyStackRef_None); + gen->gi_exc_state.previous_item = tstate->exc_info; + tstate->exc_info = &gen->gi_exc_state; + pushed_frame->previous = frame; + frame->return_offset = (uint16_t)( 2u + oparg); + gen_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache3 = gen_frame; + _tos_cache2 = _stack_item_2; + _tos_cache1 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; #else - attr = PyStackRef_FromPyObjectNew(attr_o); + Py_UNREACHABLE(); #endif - STAT_INC(LOAD_ATTR, hit); - o = owner; - _tos_cache2 = o; - _tos_cache1 = attr; + } + + case _FOR_ITER_GEN_FRAME_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef iter; + _PyStackRef gen_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + iter = _stack_item_2; + PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); + if (Py_TYPE(gen) != &PyGen_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + if (!gen_try_set_executing((PyGenObject *)gen)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(FOR_ITER, hit); + _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; + _PyFrame_StackPush(pushed_frame, PyStackRef_None); + gen->gi_exc_state.previous_item = tstate->exc_info; + tstate->exc_info = &gen->gi_exc_state; + pushed_frame->previous = frame; + frame->return_offset = (uint16_t)( 2u + oparg); + gen_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache4 = gen_frame; + _tos_cache3 = _stack_item_3; + _tos_cache2 = iter; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _INSERT_NULL_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef self; + _PyStackRef *method_and_self; + _PyStackRef _stack_item_0 = _tos_cache0; + self = _stack_item_0; + method_and_self = &stack_pointer[0]; + method_and_self[1] = self; + method_and_self[0] = PyStackRef_NULL; + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_SPECIAL_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *method_and_self; + oparg = CURRENT_OPARG(); + method_and_self = &stack_pointer[-2]; + PyObject *name = _Py_SpecialMethods[oparg].name; + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _PyObject_LookupSpecialMethod(name, method_and_self); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err <= 0) { + if (err == 0) { + PyObject *owner = PyStackRef_AsPyObjectBorrow(method_and_self[1]); + _PyFrame_SetStackPointer(frame, stack_pointer); + const char *errfmt = _PyEval_SpecialMethodCanSuggest(owner, oparg) + ? _Py_SpecialMethods[oparg].error_suggestion + : _Py_SpecialMethods[oparg].error; + stack_pointer = _PyFrame_GetStackPointer(frame); + assert(!_PyErr_Occurred(tstate)); + assert(errfmt != NULL); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyErr_Format(tstate, PyExc_TypeError, errfmt, owner); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _CHECK_ATTR_CLASS_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _WITH_EXCEPT_START_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - owner = stack_pointer[-1]; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - if (!PyType_Check(owner_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + _PyStackRef val; + _PyStackRef lasti; + _PyStackRef exit_self; + _PyStackRef exit_func; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + val = _stack_item_4; + lasti = _stack_item_2; + exit_self = _stack_item_1; + exit_func = _stack_item_0; + PyObject *exc, *tb; + PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); + PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); + assert(val_o && PyExceptionInstance_Check(val_o)); + exc = PyExceptionInstance_Class(val_o); + PyObject *original_tb = tb = PyException_GetTraceback(val_o); + if (tb == NULL) { + tb = Py_None; } - assert(type_version != 0); - if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { - UOP_STAT_INC(uopcode, miss); + assert(PyStackRef_IsTaggedInt(lasti)); + (void)lasti; + PyObject* res_o; + { + PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb}; + int has_self = !PyStackRef_IsNull(exit_self); + stack_pointer[0] = exit_func; + stack_pointer[1] = exit_self; + stack_pointer[2] = lasti; + stack_pointer[3] = _stack_item_3; + stack_pointer[4] = val; + stack_pointer += 5; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, + (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_XDECREF(original_tb); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + JUMP_TO_ERROR(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache4 = res; + _tos_cache3 = val; + _tos_cache2 = _stack_item_3; + _tos_cache1 = lasti; + _tos_cache0 = exit_self; + SET_CURRENT_CACHED_VALUES(5); + stack_pointer += -4; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_ATTR_CLASS_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _PUSH_EXC_INFO_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - if (!PyType_Check(owner_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); + _PyStackRef exc; + _PyStackRef prev_exc; + _PyStackRef new_exc; + exc = stack_pointer[-1]; + _PyErr_StackItem *exc_info = tstate->exc_info; + if (exc_info->exc_value != NULL) { + prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); } - assert(type_version != 0); - if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); + else { + prev_exc = PyStackRef_None; } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + assert(PyStackRef_ExceptionInstanceCheck(exc)); + exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); + new_exc = exc; + _tos_cache1 = new_exc; + _tos_cache0 = prev_exc; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_ATTR_CLASS_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _PUSH_EXC_INFO_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef exc; + _PyStackRef prev_exc; + _PyStackRef new_exc; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - if (!PyType_Check(owner_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); + exc = _stack_item_0; + _PyErr_StackItem *exc_info = tstate->exc_info; + if (exc_info->exc_value != NULL) { + prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); } - assert(type_version != 0); - if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); + else { + prev_exc = PyStackRef_None; } - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; + assert(PyStackRef_ExceptionInstanceCheck(exc)); + exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); + new_exc = exc; + _tos_cache1 = new_exc; + _tos_cache0 = prev_exc; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_ATTR_CLASS_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _PUSH_EXC_INFO_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef exc; + _PyStackRef prev_exc; + _PyStackRef new_exc; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - owner = _stack_item_2; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - if (!PyType_Check(owner_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); + exc = _stack_item_1; + _PyErr_StackItem *exc_info = tstate->exc_info; + if (exc_info->exc_value != NULL) { + prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); } - assert(type_version != 0); - if (FT_ATOMIC_LOAD_UINT_RELAXED(((PyTypeObject *)owner_o)->tp_version_tag) != type_version) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); + else { + prev_exc = PyStackRef_None; } - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; + assert(PyStackRef_ExceptionInstanceCheck(exc)); + exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); + new_exc = exc; + _tos_cache2 = new_exc; + _tos_cache1 = prev_exc; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_CLASS_r11: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[0] = owner; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp = owner; - owner = attr; - stack_pointer[-1] = owner; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = attr; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _LOAD_ATTR_PROPERTY_FRAME_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _PUSH_EXC_INFO_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef new_frame; + _PyStackRef exc; + _PyStackRef prev_exc; + _PyStackRef new_exc; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - owner = _stack_item_0; - PyObject *fget = (PyObject *)CURRENT_OPERAND0_64(); - assert((oparg & 1) == 0); - assert(Py_IS_TYPE(fget, &PyFunction_Type)); - PyFunctionObject *f = (PyFunctionObject *)fget; - PyCodeObject *code = (PyCodeObject *)f->func_code; - if ((code->co_flags & (CO_VARKEYWORDS | CO_VARARGS | CO_OPTIMIZED)) != CO_OPTIMIZED) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (code->co_kwonlyargcount) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (code->co_argcount != 1) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + exc = _stack_item_2; + _PyErr_StackItem *exc_info = tstate->exc_info; + if (exc_info->exc_value != NULL) { + prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); } - STAT_INC(LOAD_ATTR, hit); - _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, PyStackRef_FromPyObjectNew(fget), 1, frame); - pushed_frame->localsplus[0] = owner; - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + else { + prev_exc = PyStackRef_None; + } + assert(PyStackRef_ExceptionInstanceCheck(exc)); + exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); + new_exc = exc; + _tos_cache3 = new_exc; + _tos_cache2 = prev_exc; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN is not a viable micro-op for tier 2 because it has too many cache entries */ + case _PUSH_EXC_INFO_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef exc; + _PyStackRef prev_exc; + _PyStackRef new_exc; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + exc = _stack_item_3; + _PyErr_StackItem *exc_info = tstate->exc_info; + if (exc_info->exc_value != NULL) { + prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); + } + else { + prev_exc = PyStackRef_None; + } + assert(PyStackRef_ExceptionInstanceCheck(exc)); + exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); + new_exc = exc; + _tos_cache4 = new_exc; + _tos_cache3 = prev_exc; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } - case _GUARD_DORV_NO_DICT_r01: { + case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef owner; owner = stack_pointer[-1]; PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_dictoffset < 0); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - if (_PyObject_GetManagedDict(owner_o) || - !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { - UNLOCK_OBJECT(owner_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } + PyDictValues *ivs = _PyObject_InlineValues(owner_o); + if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } _tos_cache0 = owner; SET_CURRENT_CACHED_VALUES(1); @@ -9968,34 +22505,38 @@ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_DORV_NO_DICT_r11: { + case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; owner = _stack_item_0; PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_dictoffset < 0); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - if (_PyObject_GetManagedDict(owner_o) || - !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { - UNLOCK_OBJECT(owner_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + PyDictValues *ivs = _PyObject_InlineValues(owner_o); + if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); } _tos_cache0 = owner; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_DORV_NO_DICT_r22: { + case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef owner; @@ -10003,27 +22544,27 @@ _PyStackRef _stack_item_1 = _tos_cache1; owner = _stack_item_1; PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_dictoffset < 0); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - if (_PyObject_GetManagedDict(owner_o) || - !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { - UNLOCK_OBJECT(owner_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + PyDictValues *ivs = _PyObject_InlineValues(owner_o); + if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); } _tos_cache1 = owner; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_DORV_NO_DICT_r33: { + case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef owner; @@ -10032,6078 +22573,7714 @@ _PyStackRef _stack_item_2 = _tos_cache2; owner = _stack_item_2; PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_dictoffset < 0); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - if (_PyObject_GetManagedDict(owner_o) || - !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) { - UNLOCK_OBJECT(owner_o); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - } - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _STORE_ATTR_INSTANCE_VALUE_r21: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef value; - _PyStackRef o; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - value = _stack_item_0; - uint16_t offset = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - STAT_INC(STORE_ATTR, hit); - assert(_PyObject_GetManagedDict(owner_o) == NULL); - PyObject **value_ptr = (PyObject**)(((char *)owner_o) + offset); - PyObject *old_value = *value_ptr; - FT_ATOMIC_STORE_PTR_RELEASE(*value_ptr, PyStackRef_AsPyObjectSteal(value)); - if (old_value == NULL) { - PyDictValues *values = _PyObject_InlineValues(owner_o); - Py_ssize_t index = value_ptr - values->values; - _PyDictValues_AddToInsertionOrder(values, index); - } - UNLOCK_OBJECT(owner_o); - o = owner; - stack_pointer[0] = o; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_XDECREF(old_value); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = o; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _STORE_ATTR_WITH_HINT_r21: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef value; - _PyStackRef o; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - owner = _stack_item_1; - value = _stack_item_0; - uint16_t hint = (uint16_t)CURRENT_OPERAND0_16(); - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_MANAGED_DICT); - PyDictObject *dict = _PyObject_GetManagedDict(owner_o); - if (dict == NULL) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - if (!LOCK_OBJECT(dict)) { + PyDictValues *ivs = _PyObject_InlineValues(owner_o); + if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - assert(PyDict_CheckExact((PyObject *)dict)); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - if (hint >= (size_t)dict->ma_keys->dk_nentries || - dict->ma_keys->dk_kind != DICT_KEYS_UNICODE) { - UNLOCK_OBJECT(dict); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - } - PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint; - if (ep->me_key != name) { - UNLOCK_OBJECT(dict); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - } - PyObject *old_value = ep->me_value; - if (old_value == NULL) { - UNLOCK_OBJECT(dict); - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - } - stack_pointer[0] = value; - stack_pointer[1] = owner; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyDict_NotifyEvent(PyDict_EVENT_MODIFIED, dict, name, PyStackRef_AsPyObjectBorrow(value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - FT_ATOMIC_STORE_PTR_RELEASE(ep->me_value, PyStackRef_AsPyObjectSteal(value)); - UNLOCK_OBJECT(dict); - STAT_INC(STORE_ATTR, hit); - o = owner; - stack_pointer[-2] = o; - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_XDECREF(old_value); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = o; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _STORE_ATTR_SLOT_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef owner; - _PyStackRef value; - _PyStackRef o; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - value = _stack_item_0; - uint16_t index = (uint16_t)CURRENT_OPERAND0_16(); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - if (!LOCK_OBJECT(owner_o)) { + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + PyDictValues *ivs = _PyObject_InlineValues(owner_o); + if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - char *addr = (char *)owner_o + index; - STAT_INC(STORE_ATTR, hit); - PyObject *old_value = *(PyObject **)addr; - FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value)); - UNLOCK_OBJECT(owner_o); - o = owner; - stack_pointer[0] = o; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_XDECREF(old_value); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = o; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COMPARE_OP_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert((oparg >> 5) <= Py_GE); - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); - _PyStackRef tmp = right; - right = PyStackRef_NULL; - stack_pointer[-1] = right; - PyStackRef_CLOSE(tmp); - tmp = left; - left = PyStackRef_NULL; - stack_pointer[-2] = left; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (oparg & 16) { - _PyFrame_SetStackPointer(frame, stack_pointer); - int res_bool = PyObject_IsTrue(res_o); - Py_DECREF(res_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_bool < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = res_bool ? PyStackRef_True : PyStackRef_False; - } - else { - res = PyStackRef_FromPyObjectSteal(res_o); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + owner = _stack_item_4; + PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); + assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); + PyDictValues *ivs = _PyObject_InlineValues(owner_o); + if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COMPARE_OP_FLOAT_r03: { + case _GUARD_KEYS_VERSION_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - oparg = CURRENT_OPARG(); - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - STAT_INC(COMPARE_OP, hit); - double dleft = PyFloat_AS_DOUBLE(left_o); - double dright = PyFloat_AS_DOUBLE(right_o); - int sign_ish = COMPARISON_BIT(dleft, dright); - l = left; - r = right; - res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + _PyStackRef owner; + owner = stack_pointer[-1]; + uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; + PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COMPARE_OP_FLOAT_r13: { + case _GUARD_KEYS_VERSION_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - STAT_INC(COMPARE_OP, hit); - double dleft = PyFloat_AS_DOUBLE(left_o); - double dright = PyFloat_AS_DOUBLE(right_o); - int sign_ish = COMPARISON_BIT(dleft, dright); - l = left; - r = right; - res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + owner = _stack_item_0; + uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; + PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = owner; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COMPARE_OP_FLOAT_r23: { + case _GUARD_KEYS_VERSION_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - STAT_INC(COMPARE_OP, hit); - double dleft = PyFloat_AS_DOUBLE(left_o); - double dright = PyFloat_AS_DOUBLE(right_o); - int sign_ish = COMPARISON_BIT(dleft, dright); - l = left; - r = right; - res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; + owner = _stack_item_1; + uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; + PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = owner; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_KEYS_VERSION_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + owner = _stack_item_2; + uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; + PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = owner; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COMPARE_OP_INT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_KEYS_VERSION_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(_PyLong_IsCompact((PyLongObject *)left_o)); - assert(_PyLong_IsCompact((PyLongObject *)right_o)); - STAT_INC(COMPARE_OP, hit); - assert(_PyLong_DigitCount((PyLongObject *)left_o) <= 1 && - _PyLong_DigitCount((PyLongObject *)right_o) <= 1); - Py_ssize_t ileft = _PyLong_CompactValue((PyLongObject *)left_o); - Py_ssize_t iright = _PyLong_CompactValue((PyLongObject *)right_o); - int sign_ish = COMPARISON_BIT(ileft, iright); - l = left; - r = right; - res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; + PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COMPARE_OP_STR_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_KEYS_VERSION_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - STAT_INC(COMPARE_OP, hit); - int eq = _PyUnicode_Equal(left_o, right_o); - assert((oparg >> 5) == Py_EQ || (oparg >> 5) == Py_NE); - l = left; - r = right; - assert(eq == 0 || eq == 1); - assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); - assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); - res = ((COMPARISON_NOT_EQUALS + eq) & oparg) ? PyStackRef_True : PyStackRef_False; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + owner = _stack_item_4; + uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); + PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); + PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; + PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; + if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _IS_OP_r03: { + case _LOAD_ATTR_METHOD_WITH_VALUES_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef b; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; oparg = CURRENT_OPARG(); - right = stack_pointer[-1]; - left = stack_pointer[-2]; - int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg; - b = res ? PyStackRef_True : PyStackRef_False; - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = b; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + owner = stack_pointer[-1]; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache1 = self; + _tos_cache0 = attr; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _IS_OP_r13: { + case _LOAD_ATTR_METHOD_WITH_VALUES_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef b; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; oparg = CURRENT_OPARG(); - right = _stack_item_0; - left = stack_pointer[-1]; - int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg; - b = res ? PyStackRef_True : PyStackRef_False; - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = b; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + owner = _stack_item_0; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache1 = self; + _tos_cache0 = attr; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _IS_OP_r23: { + case _LOAD_ATTR_METHOD_WITH_VALUES_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef b; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; oparg = CURRENT_OPARG(); - right = _stack_item_1; - left = _stack_item_0; - int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg; - b = res ? PyStackRef_True : PyStackRef_False; - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = b; + owner = _stack_item_1; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache2 = self; + _tos_cache1 = attr; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CONTAINS_OP_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_ATTR_METHOD_WITH_VALUES_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef b; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; oparg = CURRENT_OPARG(); - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int res = PySequence_Contains(right_o, left_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = b; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + owner = _stack_item_2; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache3 = self; + _tos_cache2 = attr; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_METHOD_WITH_VALUES_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + owner = _stack_item_3; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache4 = self; + _tos_cache3 = attr; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_ANY_SET_r01: { + case _LOAD_ATTR_METHOD_NO_DICT_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - tos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyAnySet_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; + oparg = CURRENT_OPARG(); + owner = stack_pointer[-1]; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache1 = self; + _tos_cache0 = attr; + SET_CURRENT_CACHED_VALUES(2); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_ANY_SET_r11: { + case _LOAD_ATTR_METHOD_NO_DICT_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; - tos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyAnySet_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); + oparg = CURRENT_OPARG(); + owner = _stack_item_0; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache1 = self; + _tos_cache0 = attr; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_ANY_SET_r22: { + case _LOAD_ATTR_METHOD_NO_DICT_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyAnySet_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = tos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = tos; + oparg = CURRENT_OPARG(); + owner = _stack_item_1; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache2 = self; + _tos_cache1 = attr; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_ANY_SET_r33: { + case _LOAD_ATTR_METHOD_NO_DICT_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - tos = _stack_item_2; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyAnySet_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = tos; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = tos; + oparg = CURRENT_OPARG(); + owner = _stack_item_2; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache3 = self; + _tos_cache2 = attr; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_SET_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _LOAD_ATTR_METHOD_NO_DICT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - tos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PySet_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + owner = _stack_item_3; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache4 = self; + _tos_cache3 = attr; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_SET_r11: { + case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef owner; + _PyStackRef attr; _PyStackRef _stack_item_0 = _tos_cache0; - tos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PySet_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = tos; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = tos; + oparg = CURRENT_OPARG(); + owner = _stack_item_0; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert((oparg & 1) == 0); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(owner); + stack_pointer = _PyFrame_GetStackPointer(frame); + attr = PyStackRef_FromPyObjectNew(descr); + _tos_cache0 = attr; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_SET_r22: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PySet_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = tos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = tos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_TOS_SET_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef owner; + _PyStackRef attr; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - tos = _stack_item_2; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PySet_CheckExact(o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = tos; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = tos; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + oparg = CURRENT_OPARG(); + owner = _stack_item_0; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert((oparg & 1) == 0); + assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(owner); + stack_pointer = _PyFrame_GetStackPointer(frame); + attr = PyStackRef_FromPyObjectNew(descr); + _tos_cache0 = attr; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FROZENSET_r01: { + case _CHECK_ATTR_METHOD_LAZY_DICT_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; - tos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyFrozenSet_CheckExact(o)) { + _PyStackRef owner; + owner = stack_pointer[-1]; + uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); + char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; + PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); + if (dict != NULL) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = tos; + _tos_cache0 = owner; SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FROZENSET_r11: { + case _CHECK_ATTR_METHOD_LAZY_DICT_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; - tos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyFrozenSet_CheckExact(o)) { + owner = _stack_item_0; + uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); + char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; + PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); + if (dict != NULL) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = tos; + _tos_cache0 = owner; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = tos; + _tos_cache0 = owner; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FROZENSET_r22: { + case _CHECK_ATTR_METHOD_LAZY_DICT_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - tos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyFrozenSet_CheckExact(o)) { + owner = _stack_item_1; + uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); + char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; + PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); + if (dict != NULL) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = tos; + _tos_cache1 = owner; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = tos; + _tos_cache1 = owner; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_TOS_FROZENSET_r33: { + case _CHECK_ATTR_METHOD_LAZY_DICT_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef tos; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - tos = _stack_item_2; - PyObject *o = PyStackRef_AsPyObjectBorrow(tos); - if (!PyFrozenSet_CheckExact(o)) { + owner = _stack_item_2; + uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); + char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; + PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); + if (dict != NULL) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = tos; + _tos_cache2 = owner; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = tos; + _tos_cache2 = owner; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CONTAINS_OP_SET_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_ATTR_METHOD_LAZY_DICT_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef b; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyAnySet_CheckExact(right_o)); - STAT_INC(CONTAINS_OP, hit); - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int res = _PySet_Contains((PySetObject *)right_o, left_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + owner = _stack_item_3; + uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); + char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; + PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); + if (dict != NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = b; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache3 = owner; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CONTAINS_OP_DICT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_ATTR_METHOD_LAZY_DICT_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef b; - _PyStackRef l; - _PyStackRef r; + _PyStackRef owner; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyAnyDict_CheckExact(right_o)); - STAT_INC(CONTAINS_OP, hit); - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int res = PyDict_Contains(right_o, left_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + owner = _stack_item_4; + uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); + char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; + PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); + if (dict != NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = b; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache4 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; - } - - case _CHECK_EG_MATCH_r22: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef match_type_st; - _PyStackRef exc_value_st; - _PyStackRef rest; - _PyStackRef match; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - match_type_st = _stack_item_1; - exc_value_st = _stack_item_0; - PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); - PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); - stack_pointer[0] = exc_value_st; - stack_pointer[1] = match_type_st; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp = match_type_st; - match_type_st = PyStackRef_NULL; - stack_pointer[-1] = match_type_st; - PyStackRef_CLOSE(tmp); - tmp = exc_value_st; - exc_value_st = PyStackRef_NULL; - stack_pointer[-2] = exc_value_st; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - PyObject *match_o = NULL; - PyObject *rest_o = NULL; - _PyFrame_SetStackPointer(frame, stack_pointer); - int res = _PyEval_ExceptionGroupMatch(frame, exc_value, match_type, - &match_o, &rest_o); - _PyStackRef tmp = match_type_st; - match_type_st = PyStackRef_NULL; - stack_pointer[-1] = match_type_st; - PyStackRef_CLOSE(tmp); - tmp = exc_value_st; - exc_value_st = PyStackRef_NULL; - stack_pointer[-2] = exc_value_st; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (res < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - assert((match_o == NULL) == (rest_o == NULL)); - if (match_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (!Py_IsNone(match_o)) { - _PyFrame_SetStackPointer(frame, stack_pointer); - PyErr_SetHandledException(match_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - rest = PyStackRef_FromPyObjectSteal(rest_o); - match = PyStackRef_FromPyObjectSteal(match_o); - _tos_cache1 = match; - _tos_cache0 = rest; - _tos_cache2 = PyStackRef_ZERO_BITS; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_ATTR_METHOD_LAZY_DICT_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; + oparg = CURRENT_OPARG(); + owner = stack_pointer[-1]; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache1 = self; + _tos_cache0 = attr; SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_EXC_MATCH_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_ATTR_METHOD_LAZY_DICT_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef b; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyExceptionInstance_Check(left_o)); - stack_pointer[0] = left; - stack_pointer[1] = right; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _PyEval_CheckExceptTypeValid(tstate, right_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - int res = PyErr_GivenExceptionMatches(left_o, right_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(right); - stack_pointer = _PyFrame_GetStackPointer(frame); - b = res ? PyStackRef_True : PyStackRef_False; - _tos_cache1 = b; - _tos_cache0 = left; - _tos_cache2 = PyStackRef_ZERO_BITS; + oparg = CURRENT_OPARG(); + owner = _stack_item_0; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache1 = self; + _tos_cache0 = attr; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _IMPORT_NAME_r21: { + case _LOAD_ATTR_METHOD_LAZY_DICT_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef fromlist; - _PyStackRef level; - _PyStackRef res; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; oparg = CURRENT_OPARG(); - fromlist = _stack_item_1; - level = _stack_item_0; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); - PyObject *res_o; - if (!(oparg & 0x02)) { - stack_pointer[0] = level; - stack_pointer[1] = fromlist; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = _PyEval_LazyImportName(tstate, BUILTINS(), GLOBALS(), - LOCALS(), name, - PyStackRef_AsPyObjectBorrow(fromlist), - PyStackRef_AsPyObjectBorrow(level), - oparg & 0x01); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else { - stack_pointer[0] = level; - stack_pointer[1] = fromlist; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = _PyEval_ImportName(tstate, BUILTINS(), GLOBALS(), - LOCALS(), name, - PyStackRef_AsPyObjectBorrow(fromlist), - PyStackRef_AsPyObjectBorrow(level)); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp = fromlist; - fromlist = PyStackRef_NULL; - stack_pointer[-1] = fromlist; - PyStackRef_CLOSE(tmp); - tmp = level; - level = PyStackRef_NULL; - stack_pointer[-2] = level; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + owner = _stack_item_1; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache2 = self; + _tos_cache1 = attr; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _IMPORT_FROM_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_ATTR_METHOD_LAZY_DICT_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef from; - _PyStackRef res; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; oparg = CURRENT_OPARG(); - from = _stack_item_0; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - PyObject *res_o; - if (PyLazyImport_CheckExact(PyStackRef_AsPyObjectBorrow(from))) { - stack_pointer[0] = from; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = _PyEval_LazyImportFrom( - tstate, frame, PyStackRef_AsPyObjectBorrow(from), name); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else { - stack_pointer[0] = from; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = _PyEval_ImportFrom( - tstate, PyStackRef_AsPyObjectBorrow(from), name); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - if (res_o == NULL) { - stack_pointer[-1] = from; - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache1 = res; - _tos_cache0 = from; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + owner = _stack_item_2; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache3 = self; + _tos_cache2 = attr; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _POP_JUMP_IF_FALSE is not a viable micro-op for tier 2 because it is replaced */ - - /* _POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 because it is replaced */ - - case _IS_NONE_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_ATTR_METHOD_LAZY_DICT_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - _PyStackRef b; + _PyStackRef owner; + _PyStackRef attr; + _PyStackRef self; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - if (PyStackRef_IsNone(value)) { - b = PyStackRef_True; - } - else { - b = PyStackRef_False; - stack_pointer[0] = value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + owner = _stack_item_3; + PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); + assert(oparg & 1); + STAT_INC(LOAD_ATTR, hit); + assert(descr != NULL); + assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); + attr = PyStackRef_FromPyObjectNew(descr); + self = owner; + _tos_cache4 = self; + _tos_cache3 = attr; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _MAYBE_EXPAND_METHOD_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef self_or_null; + _PyStackRef callable; + oparg = CURRENT_OPARG(); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + self_or_null = PyStackRef_FromPyObjectNew(self); + PyObject *method = ((PyMethodObject *)callable_o)->im_func; + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp = value; - value = b; - stack_pointer[-1] = value; - PyStackRef_CLOSE(tmp); + PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; } - _tos_cache0 = b; + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - /* _JUMP_BACKWARD_NO_INTERRUPT is not a viable micro-op for tier 2 because it is replaced */ + /* _DO_CALL is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ - case _GET_LEN_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + /* _MONITOR_CALL is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ + + case _PY_FRAME_GENERAL_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef obj; - _PyStackRef len; - _PyStackRef _stack_item_0 = _tos_cache0; - obj = _stack_item_0; - stack_pointer[0] = obj; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef new_frame; + oparg = CURRENT_OPARG(); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + int total_args = oparg; + if (!PyStackRef_IsNull(self_or_null)) { + args--; + total_args++; + } + assert(Py_TYPE(callable_o) == &PyFunction_Type); + int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags; + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); - Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); + _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( + tstate, callable, locals, + args, total_args, NULL, frame + ); stack_pointer = _PyFrame_GetStackPointer(frame); - if (len_i < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - PyObject *len_o = PyLong_FromSsize_t(len_i); - if (len_o == NULL) { + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (temp == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - len = PyStackRef_FromPyObjectSteal(len_o); - _tos_cache1 = len; - _tos_cache0 = obj; + new_frame = PyStackRef_Wrap(temp); + _tos_cache0 = new_frame; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MATCH_CLASS_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_FUNCTION_VERSION_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef names; - _PyStackRef type; - _PyStackRef subject; - _PyStackRef attrs; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef callable; oparg = CURRENT_OPARG(); - names = _stack_item_2; - type = _stack_item_1; - subject = _stack_item_0; - assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); - stack_pointer[0] = subject; - stack_pointer[1] = type; - stack_pointer[2] = names; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *attrs_o = _PyEval_MatchClass(tstate, - PyStackRef_AsPyObjectBorrow(subject), - PyStackRef_AsPyObjectBorrow(type), oparg, - PyStackRef_AsPyObjectBorrow(names)); - _PyStackRef tmp = names; - names = PyStackRef_NULL; - stack_pointer[-1] = names; - PyStackRef_CLOSE(tmp); - tmp = type; - type = PyStackRef_NULL; - stack_pointer[-2] = type; - PyStackRef_CLOSE(tmp); - tmp = subject; - subject = PyStackRef_NULL; - stack_pointer[-3] = subject; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (attrs_o) { - assert(PyTuple_CheckExact(attrs_o)); - attrs = PyStackRef_FromPyObjectSteal(attrs_o); + callable = stack_pointer[-2 - oparg]; + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (!PyFunction_Check(callable_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - else { - if (_PyErr_Occurred(tstate)) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - attrs = PyStackRef_None; + PyFunctionObject *func = (PyFunctionObject *)callable_o; + if (func->func_version != func_version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = attrs; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _MATCH_MAPPING_r02: { + case _CHECK_FUNCTION_VERSION_INLINE_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef subject; - _PyStackRef res; - subject = stack_pointer[-1]; - int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; - res = match ? PyStackRef_True : PyStackRef_False; - _tos_cache1 = res; - _tos_cache0 = subject; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); + assert(PyFunction_Check(callable_o)); + PyFunctionObject *func = (PyFunctionObject *)callable_o; + if (func->func_version != func_version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _MATCH_MAPPING_r12: { + case _CHECK_FUNCTION_VERSION_INLINE_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef subject; - _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; - subject = _stack_item_0; - int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; - res = match ? PyStackRef_True : PyStackRef_False; - _tos_cache1 = res; - _tos_cache0 = subject; - SET_CURRENT_CACHED_VALUES(2); + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); + assert(PyFunction_Check(callable_o)); + PyFunctionObject *func = (PyFunctionObject *)callable_o; + if (func->func_version != func_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MATCH_MAPPING_r23: { + case _CHECK_FUNCTION_VERSION_INLINE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef subject; - _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - subject = _stack_item_1; - int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; - res = match ? PyStackRef_True : PyStackRef_False; - _tos_cache2 = res; - _tos_cache1 = subject; + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); + assert(PyFunction_Check(callable_o)); + PyFunctionObject *func = (PyFunctionObject *)callable_o; + if (func->func_version != func_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _MATCH_SEQUENCE_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef subject; - _PyStackRef res; - subject = stack_pointer[-1]; - int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; - res = match ? PyStackRef_True : PyStackRef_False; - _tos_cache1 = res; - _tos_cache0 = subject; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _MATCH_SEQUENCE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef subject; - _PyStackRef res; - _PyStackRef _stack_item_0 = _tos_cache0; - subject = _stack_item_0; - int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; - res = match ? PyStackRef_True : PyStackRef_False; - _tos_cache1 = res; - _tos_cache0 = subject; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MATCH_SEQUENCE_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_FUNCTION_VERSION_INLINE_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef subject; - _PyStackRef res; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - subject = _stack_item_1; - int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; - res = match ? PyStackRef_True : PyStackRef_False; - _tos_cache2 = res; - _tos_cache1 = subject; + _PyStackRef _stack_item_2 = _tos_cache2; + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); + assert(PyFunction_Check(callable_o)); + PyFunctionObject *func = (PyFunctionObject *)callable_o; + if (func->func_version != func_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MATCH_KEYS_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_FUNCTION_VERSION_INLINE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef keys; - _PyStackRef subject; - _PyStackRef values_or_none; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - keys = _stack_item_1; - subject = _stack_item_0; - stack_pointer[0] = subject; - stack_pointer[1] = keys; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, - PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (values_or_none_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); + assert(PyFunction_Check(callable_o)); + PyFunctionObject *func = (PyFunctionObject *)callable_o; + if (func->func_version != func_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); - _tos_cache2 = values_or_none; - _tos_cache1 = keys; - _tos_cache0 = subject; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GET_ITER_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CHECK_FUNCTION_VERSION_INLINE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iterable; - _PyStackRef iter; - _PyStackRef index_or_null; _PyStackRef _stack_item_0 = _tos_cache0; - iterable = _stack_item_0; - #ifdef Py_STATS - stack_pointer[0] = iterable; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_GatherStats_GetIter(iterable); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - #endif - PyTypeObject *tp = PyStackRef_TYPE(iterable); - if (tp == &PyTuple_Type || tp == &PyList_Type) { - iter = iterable; - index_or_null = PyStackRef_TagInt(0); - } - else { - stack_pointer[0] = iterable; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *iter_o = PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable)); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(iterable); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (iter_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - iter = PyStackRef_FromPyObjectSteal(iter_o); - index_or_null = PyStackRef_NULL; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); + assert(PyFunction_Check(callable_o)); + PyFunctionObject *func = (PyFunctionObject *)callable_o; + if (func->func_version != func_version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = index_or_null; - _tos_cache0 = iter; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GET_YIELD_FROM_ITER_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CHECK_METHOD_VERSION_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iterable; - _PyStackRef iter; - _PyStackRef _stack_item_0 = _tos_cache0; - iterable = _stack_item_0; - PyObject *iterable_o = PyStackRef_AsPyObjectBorrow(iterable); - if (PyCoro_CheckExact(iterable_o)) { - if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { - stack_pointer[0] = iterable; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetString(tstate, PyExc_TypeError, - "cannot 'yield from' a coroutine object " - "in a non-coroutine generator"); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - iter = iterable; + _PyStackRef null; + _PyStackRef callable; + oparg = CURRENT_OPARG(); + null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (Py_TYPE(callable_o) != &PyMethod_Type) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - else if (PyGen_CheckExact(iterable_o)) { - iter = iterable; + PyObject *func = ((PyMethodObject *)callable_o)->im_func; + if (!PyFunction_Check(func)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - else { - stack_pointer[0] = iterable; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *iter_o = PyObject_GetIter(iterable_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (iter_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - iter = PyStackRef_FromPyObjectSteal(iter_o); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp = iterable; - iterable = iter; - stack_pointer[-1] = iterable; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; + if (((PyFunctionObject *)func)->func_version != func_version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = iter; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - /* _FOR_ITER is not a viable micro-op for tier 2 because it is replaced */ - - case _FOR_ITER_TIER_TWO_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _EXPAND_METHOD_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef next; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - null_or_index = _stack_item_1; - iter = _stack_item_0; - stack_pointer[0] = iter; - stack_pointer[1] = null_or_index; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef self_or_null; + _PyStackRef callable; + oparg = CURRENT_OPARG(); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + assert(PyStackRef_IsNull(self_or_null)); + assert(Py_TYPE(callable_o) == &PyMethod_Type); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(callable)); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, iter, &null_or_index); + PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); - if (!PyStackRef_IsValid(item)) { - if (PyStackRef_IsError(item)) { - stack_pointer[-1] = null_or_index; - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - if (true) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); - } - } - next = item; - _tos_cache2 = next; - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - /* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 because it is instrumented */ - - case _ITER_CHECK_LIST_r02: { + case _CHECK_IS_NOT_PY_CALLABLE_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - null_or_index = stack_pointer[-1]; - iter = stack_pointer[-2]; - PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(iter_o) != &PyList_Type) { + _PyStackRef callable; + oparg = CURRENT_OPARG(); + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_IsTaggedInt(null_or_index)); - #ifdef Py_GIL_DISABLED - if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { + if (Py_TYPE(callable_o) == &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - #endif - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _ITER_CHECK_LIST_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CALL_NON_PY_GENERAL_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef _stack_item_0 = _tos_cache0; - null_or_index = _stack_item_0; - iter = stack_pointer[-1]; - PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(iter_o) != &PyList_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = null_or_index; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef res; + oparg = CURRENT_OPARG(); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + #if TIER_ONE + assert(opcode != INSTRUMENTED_CALL); + #endif + int total_args = oparg; + _PyStackRef *arguments = args; + if (!PyStackRef_IsNull(self_or_null)) { + arguments--; + total_args++; } - assert(PyStackRef_IsTaggedInt(null_or_index)); - #ifdef Py_GIL_DISABLED - if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = null_or_index; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _Py_VectorCall_StackRefSteal( + callable, + arguments, + total_args, + PyStackRef_NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; #endif - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_CHECK_LIST_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - null_or_index = _stack_item_1; - iter = _stack_item_0; - PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(iter_o) != &PyList_Type) { + _PyStackRef null; + _PyStackRef callable; + oparg = CURRENT_OPARG(); + null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_IsTaggedInt(null_or_index)); - #ifdef Py_GIL_DISABLED - if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { + if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - #endif - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _ITER_CHECK_LIST_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - null_or_index = _stack_item_2; - iter = _stack_item_1; - PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(iter_o) != &PyList_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = null_or_index; - _tos_cache1 = iter; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - assert(PyStackRef_IsTaggedInt(null_or_index)); - #ifdef Py_GIL_DISABLED - if (!_Py_IsOwnedByCurrentThread(iter_o) && !_PyObject_GC_IS_SHARED(iter_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = null_or_index; - _tos_cache1 = iter; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef self_or_null; + _PyStackRef callable; + oparg = CURRENT_OPARG(); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + assert(PyStackRef_IsNull(self_or_null)); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + STAT_INC(CALL, hit); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(temp); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; #endif - _tos_cache2 = null_or_index; - _tos_cache1 = iter; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 because it is replaced */ - - case _GUARD_NOT_EXHAUSTED_LIST_r02: { + case _CHECK_PEP_523_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - null_or_index = stack_pointer[-1]; - iter = stack_pointer[-2]; - #ifndef Py_GIL_DISABLED - PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(list_o) == &PyList_Type); - if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + if (IS_PEP523_HOOKED(tstate)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - #endif - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _GUARD_NOT_EXHAUSTED_LIST_r12: { + case _CHECK_PEP_523_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; - null_or_index = _stack_item_0; - iter = stack_pointer[-1]; - #ifndef Py_GIL_DISABLED - PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(list_o) == &PyList_Type); - if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + if (IS_PEP523_HOOKED(tstate)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = null_or_index; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - #endif - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOT_EXHAUSTED_LIST_r22: { + case _CHECK_PEP_523_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - null_or_index = _stack_item_1; - iter = _stack_item_0; - #ifndef Py_GIL_DISABLED - PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(list_o) == &PyList_Type); - if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + if (IS_PEP523_HOOKED(tstate)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - #endif - _tos_cache1 = null_or_index; - _tos_cache0 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOT_EXHAUSTED_LIST_r33: { + case _CHECK_PEP_523_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - null_or_index = _stack_item_2; - iter = _stack_item_1; - #ifndef Py_GIL_DISABLED - PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(list_o) == &PyList_Type); - if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyList_GET_SIZE(list_o)) { + if (IS_PEP523_HOOKED(tstate)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = null_or_index; - _tos_cache1 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - #endif - _tos_cache2 = null_or_index; - _tos_cache1 = iter; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _ITER_NEXT_LIST is not a viable micro-op for tier 2 because it is replaced */ - - case _ITER_NEXT_LIST_TIER_TWO_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_PEP_523_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef next; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - null_or_index = _stack_item_1; - iter = _stack_item_0; - PyObject *list_o = PyStackRef_AsPyObjectBorrow(iter); - assert(PyList_CheckExact(list_o)); - #ifdef Py_GIL_DISABLED - assert(_Py_IsOwnedByCurrentThread((PyObject *)list_o) || - _PyObject_GC_IS_SHARED(list_o)); - STAT_INC(FOR_ITER, hit); - stack_pointer[0] = iter; - stack_pointer[1] = null_or_index; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int result = _PyList_GetItemRefNoLock((PyListObject *)list_o, PyStackRef_UntagInt(null_or_index), &next); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (result <= 0) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + if (IS_PEP523_HOOKED(tstate)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; #else - assert(PyStackRef_UntagInt(null_or_index) < PyList_GET_SIZE(list_o)); - next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(list_o, PyStackRef_UntagInt(null_or_index))); - stack_pointer += 2; + Py_UNREACHABLE(); #endif - null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); - _tos_cache2 = next; - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + } + + case _CHECK_PEP_523_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + if (IS_PEP523_HOOKED(tstate)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_CHECK_TUPLE_r02: { + case _CHECK_FUNCTION_EXACT_ARGS_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - null_or_index = stack_pointer[-1]; - iter = stack_pointer[-2]; - PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(iter_o) != &PyTuple_Type) { + _PyStackRef self_or_null; + _PyStackRef callable; + oparg = CURRENT_OPARG(); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + assert(PyFunction_Check(callable_o)); + PyFunctionObject *func = (PyFunctionObject *)callable_o; + PyCodeObject *code = (PyCodeObject *)func->func_code; + if (code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null))) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_IsTaggedInt(null_or_index)); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _ITER_CHECK_TUPLE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CHECK_STACK_SPACE_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef _stack_item_0 = _tos_cache0; - null_or_index = _stack_item_0; - iter = stack_pointer[-1]; - PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(iter_o) != &PyTuple_Type) { + _PyStackRef callable; + oparg = CURRENT_OPARG(); + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyFunctionObject *func = (PyFunctionObject *)callable_o; + PyCodeObject *code = (PyCodeObject *)func->func_code; + if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = null_or_index; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_IsTaggedInt(null_or_index)); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _ITER_CHECK_TUPLE_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_RECURSION_REMAINING_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - null_or_index = _stack_item_1; - iter = _stack_item_0; - PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(iter_o) != &PyTuple_Type) { + if (tstate->py_recursion_remaining <= 1) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_IsTaggedInt(null_or_index)); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _ITER_CHECK_TUPLE_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_RECURSION_REMAINING_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - null_or_index = _stack_item_2; - iter = _stack_item_1; - PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(iter_o) != &PyTuple_Type) { + if (tstate->py_recursion_remaining <= 1) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = null_or_index; - _tos_cache1 = iter; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_IsTaggedInt(null_or_index)); - _tos_cache2 = null_or_index; - _tos_cache1 = iter; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 because it is replaced */ - - case _GUARD_NOT_EXHAUSTED_TUPLE_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _CHECK_RECURSION_REMAINING_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - null_or_index = stack_pointer[-1]; - iter = stack_pointer[-2]; - PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(tuple_o) == &PyTuple_Type); - if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + if (tstate->py_recursion_remaining <= 1) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = null_or_index; - _tos_cache0 = iter; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOT_EXHAUSTED_TUPLE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CHECK_RECURSION_REMAINING_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; - null_or_index = _stack_item_0; - iter = stack_pointer[-1]; - PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(tuple_o) == &PyTuple_Type); - if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + if (tstate->py_recursion_remaining <= 1) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = null_or_index; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOT_EXHAUSTED_TUPLE_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_RECURSION_REMAINING_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - null_or_index = _stack_item_1; - iter = _stack_item_0; - PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(tuple_o) == &PyTuple_Type); - if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + if (tstate->py_recursion_remaining <= 1) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOT_EXHAUSTED_TUPLE_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_RECURSION_REMAINING_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - null_or_index = _stack_item_2; - iter = _stack_item_1; - PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(tuple_o) == &PyTuple_Type); - if ((size_t)PyStackRef_UntagInt(null_or_index) >= (size_t)PyTuple_GET_SIZE(tuple_o)) { + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + if (tstate->py_recursion_remaining <= 1) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = null_or_index; - _tos_cache1 = iter; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = null_or_index; - _tos_cache1 = iter; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_NEXT_TUPLE_r03: { + case _INIT_CALL_PY_EXACT_ARGS_0_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef next; - null_or_index = stack_pointer[-1]; - iter = stack_pointer[-2]; - PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(tuple_o) == &PyTuple_Type); - uintptr_t i = PyStackRef_UntagInt(null_or_index); - assert((size_t)i < (size_t)PyTuple_GET_SIZE(tuple_o)); - next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(tuple_o, i)); - null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); - _tos_cache2 = next; - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef new_frame; + oparg = 0; + assert(oparg == CURRENT_OPARG()); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); + STAT_INC(CALL, hit); + _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); + _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; + pushed_frame->localsplus[0] = self_or_null; + for (int i = 0; i < oparg; i++) { + first_non_self_local[i] = args[i]; + } + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_NEXT_TUPLE_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _INIT_CALL_PY_EXACT_ARGS_1_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef next; - _PyStackRef _stack_item_0 = _tos_cache0; - null_or_index = _stack_item_0; - iter = stack_pointer[-1]; - PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(tuple_o) == &PyTuple_Type); - uintptr_t i = PyStackRef_UntagInt(null_or_index); - assert((size_t)i < (size_t)PyTuple_GET_SIZE(tuple_o)); - next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(tuple_o, i)); - null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); - _tos_cache2 = next; - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef new_frame; + oparg = 1; + assert(oparg == CURRENT_OPARG()); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); + STAT_INC(CALL, hit); + _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); + _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; + pushed_frame->localsplus[0] = self_or_null; + for (int i = 0; i < oparg; i++) { + first_non_self_local[i] = args[i]; + } + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_NEXT_TUPLE_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _INIT_CALL_PY_EXACT_ARGS_2_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null_or_index; - _PyStackRef iter; - _PyStackRef next; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - null_or_index = _stack_item_1; - iter = _stack_item_0; - PyObject *tuple_o = PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(tuple_o) == &PyTuple_Type); - uintptr_t i = PyStackRef_UntagInt(null_or_index); - assert((size_t)i < (size_t)PyTuple_GET_SIZE(tuple_o)); - next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(tuple_o, i)); - null_or_index = PyStackRef_IncrementTaggedIntNoOverflow(null_or_index); - _tos_cache2 = next; - _tos_cache1 = null_or_index; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef new_frame; + oparg = 2; + assert(oparg == CURRENT_OPARG()); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); + STAT_INC(CALL, hit); + _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); + _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; + pushed_frame->localsplus[0] = self_or_null; + for (int i = 0; i < oparg; i++) { + first_non_self_local[i] = args[i]; + } + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_CHECK_RANGE_r02: { + case _INIT_CALL_PY_EXACT_ARGS_3_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - iter = stack_pointer[-2]; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(r) != &PyRangeIter_Type) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - #ifdef Py_GIL_DISABLED - if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef new_frame; + oparg = 3; + assert(oparg == CURRENT_OPARG()); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); + STAT_INC(CALL, hit); + _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); + _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; + pushed_frame->localsplus[0] = self_or_null; + for (int i = 0; i < oparg; i++) { + first_non_self_local[i] = args[i]; } - #endif - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_CHECK_RANGE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _INIT_CALL_PY_EXACT_ARGS_4_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - _PyStackRef _stack_item_0 = _tos_cache0; - iter = stack_pointer[-1]; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(r) != &PyRangeIter_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - #ifdef Py_GIL_DISABLED - if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef new_frame; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); + STAT_INC(CALL, hit); + _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); + _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; + pushed_frame->localsplus[0] = self_or_null; + for (int i = 0; i < oparg; i++) { + first_non_self_local[i] = args[i]; } - #endif - _tos_cache1 = _stack_item_0; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_CHECK_RANGE_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _INIT_CALL_PY_EXACT_ARGS_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - iter = _stack_item_0; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(r) != &PyRangeIter_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - #ifdef Py_GIL_DISABLED - if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef new_frame; + oparg = CURRENT_OPARG(); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); + STAT_INC(CALL, hit); + _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); + _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; + pushed_frame->localsplus[0] = self_or_null; + for (int i = 0; i < oparg; i++) { + first_non_self_local[i] = args[i]; } - #endif - _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + new_frame = PyStackRef_Wrap(pushed_frame); + _tos_cache0 = new_frame; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _ITER_CHECK_RANGE_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _PUSH_FRAME_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; + _PyStackRef new_frame; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - iter = _stack_item_1; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(r) != &PyRangeIter_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = iter; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - #ifdef Py_GIL_DISABLED - if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = iter; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - #endif - _tos_cache2 = _stack_item_2; - _tos_cache1 = iter; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + new_frame = _stack_item_0; + assert(!IS_PEP523_HOOKED(tstate)); + _PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame); + _PyFrame_SetStackPointer(frame, stack_pointer); + assert(temp->previous == frame || temp->previous->previous == frame); + CALL_STAT_INC(inlined_py_calls); + frame = tstate->current_frame = temp; + tstate->py_recursion_remaining--; + LOAD_SP(); + LOAD_IP(0); + LLTRACE_RESUME_FRAME(); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 because it is replaced */ - - case _GUARD_NOT_EXHAUSTED_RANGE_r02: { + case _GUARD_NOS_NULL_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - iter = stack_pointer[-2]; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(r) == &PyRangeIter_Type); - if (r->len <= 0) { + _PyStackRef null; + null = stack_pointer[-2]; + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = iter; + _tos_cache0 = null; SET_CURRENT_CACHED_VALUES(2); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOT_EXHAUSTED_RANGE_r12: { + case _GUARD_NOS_NULL_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; + _PyStackRef null; _PyStackRef _stack_item_0 = _tos_cache0; - iter = stack_pointer[-1]; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(r) == &PyRangeIter_Type); - if (r->len <= 0) { + null = stack_pointer[-1]; + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } _tos_cache1 = _stack_item_0; - _tos_cache0 = iter; + _tos_cache0 = null; SET_CURRENT_CACHED_VALUES(2); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOT_EXHAUSTED_RANGE_r22: { + case _GUARD_NOS_NULL_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; + _PyStackRef null; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - iter = _stack_item_0; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(r) == &PyRangeIter_Type); - if (r->len <= 0) { + null = _stack_item_0; + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; + _tos_cache0 = null; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; + _tos_cache0 = null; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOT_EXHAUSTED_RANGE_r33: { + case _GUARD_NOS_NULL_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; + _PyStackRef null; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - iter = _stack_item_1; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(r) == &PyRangeIter_Type); - if (r->len <= 0) { + null = _stack_item_1; + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); _tos_cache2 = _stack_item_2; - _tos_cache1 = iter; + _tos_cache1 = null; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } _tos_cache2 = _stack_item_2; - _tos_cache1 = iter; + _tos_cache1 = null; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; - } - - case _ITER_NEXT_RANGE_r03: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - _PyStackRef next; - iter = stack_pointer[-2]; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(r) == &PyRangeIter_Type); - #ifdef Py_GIL_DISABLED - assert(_PyObject_IsUniquelyReferenced((PyObject *)r)); - #endif - assert(r->len > 0); - long value = r->start; - r->start = value + r->step; - r->len--; - PyObject *res = PyLong_FromLong(value); - if (res == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - next = PyStackRef_FromPyObjectSteal(res); - _tos_cache2 = next; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _ITER_NEXT_RANGE_r13: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - _PyStackRef next; - _PyStackRef _stack_item_0 = _tos_cache0; - iter = stack_pointer[-1]; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(r) == &PyRangeIter_Type); - #ifdef Py_GIL_DISABLED - assert(_PyObject_IsUniquelyReferenced((PyObject *)r)); + #else + Py_UNREACHABLE(); #endif - assert(r->len > 0); - long value = r->start; - r->start = value + r->step; - r->len--; - PyObject *res = PyLong_FromLong(value); - if (res == NULL) { - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - next = PyStackRef_FromPyObjectSteal(res); - _tos_cache2 = next; - _tos_cache1 = _stack_item_0; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; } - case _ITER_NEXT_RANGE_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_NOS_NULL_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - _PyStackRef next; + _PyStackRef null; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - iter = _stack_item_0; - _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); - assert(Py_TYPE(r) == &PyRangeIter_Type); - #ifdef Py_GIL_DISABLED - assert(_PyObject_IsUniquelyReferenced((PyObject *)r)); - #endif - assert(r->len > 0); - long value = r->start; - r->start = value + r->step; - r->len--; - PyObject *res = PyLong_FromLong(value); - if (res == NULL) { - stack_pointer[0] = iter; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + null = _stack_item_2; + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = null; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - next = PyStackRef_FromPyObjectSteal(res); - _tos_cache2 = next; - _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache3 = _stack_item_3; + _tos_cache2 = null; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _FOR_ITER_GEN_FRAME_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_NOS_NULL_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - _PyStackRef gen_frame; - oparg = CURRENT_OPARG(); - iter = stack_pointer[-2]; - PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(gen) != &PyGen_Type) { + _PyStackRef null; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + null = _stack_item_3; + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = _stack_item_4; + _tos_cache3 = null; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - if (!gen_try_set_executing((PyGenObject *)gen)) { + _tos_cache4 = _stack_item_4; + _tos_cache3 = null; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_NOT_NULL_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + nos = stack_pointer[-2]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (o == NULL) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - STAT_INC(FOR_ITER, hit); - _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; - _PyFrame_StackPush(pushed_frame, PyStackRef_None); - gen->gi_exc_state.previous_item = tstate->exc_info; - tstate->exc_info = &gen->gi_exc_state; - pushed_frame->previous = frame; - frame->return_offset = (uint16_t)( 2u + oparg); - gen_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache2 = gen_frame; _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _FOR_ITER_GEN_FRAME_r13: { + case _GUARD_NOS_NOT_NULL_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - _PyStackRef gen_frame; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - iter = stack_pointer[-1]; - PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(gen) != &PyGen_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (!gen_try_set_executing((PyGenObject *)gen)) { + nos = stack_pointer[-1]; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (o == NULL) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - STAT_INC(FOR_ITER, hit); - _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; - _PyFrame_StackPush(pushed_frame, PyStackRef_None); - gen->gi_exc_state.previous_item = tstate->exc_info; - tstate->exc_info = &gen->gi_exc_state; - pushed_frame->previous = frame; - frame->return_offset = (uint16_t)( 2u + oparg); - gen_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache2 = gen_frame; _tos_cache1 = _stack_item_0; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _FOR_ITER_GEN_FRAME_r23: { + case _GUARD_NOS_NOT_NULL_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef iter; - _PyStackRef gen_frame; + _PyStackRef nos; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - iter = _stack_item_0; - PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); - if (Py_TYPE(gen) != &PyGen_Type) { + nos = _stack_item_0; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (o == NULL) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; + _tos_cache0 = nos; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - if (!gen_try_set_executing((PyGenObject *)gen)) { + _tos_cache1 = _stack_item_1; + _tos_cache0 = nos; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_NOT_NULL_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + nos = _stack_item_1; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = nos; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_NOT_NULL_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + nos = _stack_item_2; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (o == NULL) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - STAT_INC(FOR_ITER, hit); - _PyInterpreterFrame *pushed_frame = &gen->gi_iframe; - _PyFrame_StackPush(pushed_frame, PyStackRef_None); - gen->gi_exc_state.previous_item = tstate->exc_info; - tstate->exc_info = &gen->gi_exc_state; - pushed_frame->previous = frame; - frame->return_offset = (uint16_t)( 2u + oparg); - gen_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache2 = gen_frame; + _tos_cache3 = _stack_item_3; + _tos_cache2 = nos; _tos_cache1 = _stack_item_1; - _tos_cache0 = iter; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_NOS_NOT_NULL_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef nos; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + nos = _stack_item_3; + PyObject *o = PyStackRef_AsPyObjectBorrow(nos); + if (o == NULL) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = nos; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_THIRD_NULL_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null; + null = stack_pointer[-3]; + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = null; SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INSERT_NULL_r10: { + case _GUARD_THIRD_NULL_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self; - _PyStackRef *method_and_self; + _PyStackRef null; _PyStackRef _stack_item_0 = _tos_cache0; - self = _stack_item_0; - method_and_self = &stack_pointer[0]; - method_and_self[1] = self; - method_and_self[0] = PyStackRef_NULL; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += 2; + null = stack_pointer[-2]; + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = null; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_SPECIAL_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_THIRD_NULL_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *method_and_self; - oparg = CURRENT_OPARG(); - method_and_self = &stack_pointer[-2]; - PyObject *name = _Py_SpecialMethods[oparg].name; - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _PyObject_LookupSpecialMethod(name, method_and_self); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err <= 0) { - if (err == 0) { - PyObject *owner = PyStackRef_AsPyObjectBorrow(method_and_self[1]); - _PyFrame_SetStackPointer(frame, stack_pointer); - const char *errfmt = _PyEval_SpecialMethodCanSuggest(owner, oparg) - ? _Py_SpecialMethods[oparg].error_suggestion - : _Py_SpecialMethods[oparg].error; - stack_pointer = _PyFrame_GetStackPointer(frame); - assert(!_PyErr_Occurred(tstate)); - assert(errfmt != NULL); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Format(tstate, PyExc_TypeError, errfmt, owner); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef null; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null = stack_pointer[-1]; + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = null; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _WITH_EXCEPT_START_r33: { + case _GUARD_THIRD_NULL_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef val; - _PyStackRef lasti; - _PyStackRef exit_self; - _PyStackRef exit_func; - _PyStackRef res; + _PyStackRef null; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - val = _stack_item_2; - lasti = _stack_item_0; - exit_self = stack_pointer[-1]; - exit_func = stack_pointer[-2]; - PyObject *exc, *tb; - PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); - PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); - assert(val_o && PyExceptionInstance_Check(val_o)); - exc = PyExceptionInstance_Class(val_o); - PyObject *original_tb = tb = PyException_GetTraceback(val_o); - if (tb == NULL) { - tb = Py_None; - } - assert(PyStackRef_IsTaggedInt(lasti)); - (void)lasti; - PyObject* res_o; - { - PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb}; - int has_self = !PyStackRef_IsNull(exit_self); - stack_pointer[0] = lasti; - stack_pointer[1] = _stack_item_1; - stack_pointer[2] = val; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, - (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_XDECREF(original_tb); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + null = _stack_item_0; + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = null; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache2 = res; - _tos_cache1 = val; - _tos_cache0 = _stack_item_1; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = null; SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _PUSH_EXC_INFO_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_THIRD_NULL_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef exc; - _PyStackRef prev_exc; - _PyStackRef new_exc; - exc = stack_pointer[-1]; - _PyErr_StackItem *exc_info = tstate->exc_info; - if (exc_info->exc_value != NULL) { - prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); - } - else { - prev_exc = PyStackRef_None; + _PyStackRef null; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + null = _stack_item_1; + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = null; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_ExceptionInstanceCheck(exc)); - exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); - new_exc = exc; - _tos_cache1 = new_exc; - _tos_cache0 = prev_exc; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = null; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _PUSH_EXC_INFO_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_THIRD_NULL_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef exc; - _PyStackRef prev_exc; - _PyStackRef new_exc; + _PyStackRef null; _PyStackRef _stack_item_0 = _tos_cache0; - exc = _stack_item_0; - _PyErr_StackItem *exc_info = tstate->exc_info; - if (exc_info->exc_value != NULL) { - prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + null = _stack_item_2; + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = null; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); } - else { - prev_exc = PyStackRef_None; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = null; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CALLABLE_TYPE_1_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; + callable = stack_pointer[-3]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyType_Type) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_ExceptionInstanceCheck(exc)); - exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); - new_exc = exc; - _tos_cache1 = new_exc; - _tos_cache0 = prev_exc; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _PUSH_EXC_INFO_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_CALLABLE_TYPE_1_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef exc; - _PyStackRef prev_exc; - _PyStackRef new_exc; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - exc = _stack_item_1; - _PyErr_StackItem *exc_info = tstate->exc_info; - if (exc_info->exc_value != NULL) { - prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); - } - else { - prev_exc = PyStackRef_None; + callable = stack_pointer[-2]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyType_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_ExceptionInstanceCheck(exc)); - exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); - new_exc = exc; - _tos_cache2 = new_exc; - _tos_cache1 = prev_exc; - _tos_cache0 = _stack_item_0; + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = callable; SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_TYPE_1_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - owner = stack_pointer[-1]; - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - PyDictValues *ivs = _PyObject_InlineValues(owner_o); - if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + callable = stack_pointer[-1]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyType_Type) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_CALLABLE_TYPE_1_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - PyDictValues *ivs = _PyObject_InlineValues(owner_o); - if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + callable = _stack_item_0; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyType_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_CALLABLE_TYPE_1_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - PyDictValues *ivs = _PyObject_InlineValues(owner_o); - if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + callable = _stack_item_1; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyType_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_CALLABLE_TYPE_1_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - owner = _stack_item_2; - PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); - assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); - PyDictValues *ivs = _PyObject_InlineValues(owner_o); - if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) { + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + callable = _stack_item_2; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyType_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = owner; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_KEYS_VERSION_r01: { + case _CALL_TYPE_1_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - owner = stack_pointer[-1]; - uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); - PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); - PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; - PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; + oparg = CURRENT_OPARG(); + arg = stack_pointer[-1]; + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + assert(oparg == 1); + STAT_INC(CALL, hit); + a = arg; + res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_KEYS_VERSION_r11: { + case _CALL_TYPE_1_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); - PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); - PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; - PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + oparg = CURRENT_OPARG(); + arg = _stack_item_0; + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + assert(oparg == 1); + STAT_INC(CALL, hit); + a = arg; + res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_KEYS_VERSION_r22: { + case _CALL_TYPE_1_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); - PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); - PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; - PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = owner; - _tos_cache0 = _stack_item_0; + oparg = CURRENT_OPARG(); + arg = _stack_item_1; + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + assert(oparg == 1); + STAT_INC(CALL, hit); + a = arg; + res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); + _tos_cache1 = a; + _tos_cache0 = res; SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_KEYS_VERSION_r33: { + case _CALL_TYPE_1_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - owner = _stack_item_2; - uint32_t keys_version = (uint32_t)CURRENT_OPERAND0_32(); - PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); - PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; - PyDictKeysObject *keys = owner_heap_type->ht_cached_keys; - if (FT_ATOMIC_LOAD_UINT32_RELAXED(keys->dk_version) != keys_version) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = owner; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + oparg = CURRENT_OPARG(); + arg = _stack_item_2; + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + assert(oparg == 1); + STAT_INC(CALL, hit); + a = arg; + res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_WITH_VALUES_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _CALL_TYPE_1_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef self; + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; oparg = CURRENT_OPARG(); - owner = stack_pointer[-1]; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache1 = self; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + arg = _stack_item_3; + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + assert(oparg == 1); + STAT_INC(CALL, hit); + a = arg; + res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); + _tos_cache2 = a; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_WITH_VALUES_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CALL_TYPE_1_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef self; + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; oparg = CURRENT_OPARG(); - owner = _stack_item_0; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache1 = self; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); + arg = _stack_item_4; + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + assert(oparg == 1); + STAT_INC(CALL, hit); + a = arg; + res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); + _tos_cache3 = a; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CALLABLE_STR_1_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; + callable = stack_pointer[-3]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyUnicode_Type) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_WITH_VALUES_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_CALLABLE_STR_1_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef self; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - owner = _stack_item_1; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache2 = self; - _tos_cache1 = attr; - _tos_cache0 = _stack_item_0; + callable = stack_pointer[-2]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyUnicode_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = callable; SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_NO_DICT_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_STR_1_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef self; - oparg = CURRENT_OPARG(); - owner = stack_pointer[-1]; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache1 = self; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + callable = stack_pointer[-1]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyUnicode_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_NO_DICT_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_CALLABLE_STR_1_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef self; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - owner = _stack_item_0; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache1 = self; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + callable = _stack_item_0; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyUnicode_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_NO_DICT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_CALLABLE_STR_1_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef self; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - owner = _stack_item_1; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache2 = self; - _tos_cache1 = attr; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + callable = _stack_item_1; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyUnicode_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_CALLABLE_STR_1_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - owner = _stack_item_0; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert((oparg & 1) == 0); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(owner); - stack_pointer = _PyFrame_GetStackPointer(frame); - attr = PyStackRef_FromPyObjectNew(descr); - _tos_cache0 = attr; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + callable = _stack_item_2; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyUnicode_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CALL_STR_1_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; oparg = CURRENT_OPARG(); - owner = _stack_item_0; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert((oparg & 1) == 0); - assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); + arg = _stack_item_2; + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + assert(oparg == 1); + STAT_INC(CALL, hit); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = arg; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(owner); + PyObject *res_o = PyObject_Str(arg_o); stack_pointer = _PyFrame_GetStackPointer(frame); - attr = PyStackRef_FromPyObjectNew(descr); - _tos_cache0 = attr; - _tos_cache1 = PyStackRef_ZERO_BITS; + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + a = arg; + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache1 = a; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CALLABLE_TUPLE_1_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; + callable = stack_pointer[-3]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyTuple_Type) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CALLABLE_TUPLE_1_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + callable = stack_pointer[-2]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyTuple_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_ATTR_METHOD_LAZY_DICT_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_TUPLE_1_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - owner = stack_pointer[-1]; - uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); - char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; - PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); - if (dict != NULL) { + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + callable = stack_pointer[-1]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyTuple_Type) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_ATTR_METHOD_LAZY_DICT_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_CALLABLE_TUPLE_1_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - owner = _stack_item_0; - uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); - char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; - PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); - if (dict != NULL) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + callable = _stack_item_0; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyTuple_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = owner; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_ATTR_METHOD_LAZY_DICT_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_CALLABLE_TUPLE_1_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - owner = _stack_item_1; - uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); - char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; - PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); - if (dict != NULL) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + callable = _stack_item_1; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyTuple_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = owner; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_ATTR_METHOD_LAZY_DICT_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_CALLABLE_TUPLE_1_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - owner = _stack_item_2; - uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0_16(); - char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset; - PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr); - if (dict != NULL) { + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + callable = _stack_item_2; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (callable_o != (PyObject *)&PyTuple_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = owner; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = owner; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_LAZY_DICT_r02: { + case _CALL_TUPLE_1_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + arg = _stack_item_2; + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + assert(oparg == 1); + STAT_INC(CALL, hit); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = arg; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = PySequence_Tuple(arg_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + a = arg; + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache1 = a; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_AND_ALLOCATE_OBJECT_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; + _PyStackRef self_or_null; + _PyStackRef callable; + oparg = CURRENT_OPARG(); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (!PyStackRef_IsNull(self_or_null)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + if (!PyType_Check(callable_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *tp = (PyTypeObject *)callable_o; + if (FT_ATOMIC_LOAD_UINT32_RELAXED(tp->tp_version_tag) != type_version) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + assert(tp->tp_new == PyBaseObject_Type.tp_new); + assert(tp->tp_flags & Py_TPFLAGS_HEAPTYPE); + assert(tp->tp_alloc == PyType_GenericAlloc); + PyHeapTypeObject *cls = (PyHeapTypeObject *)callable_o; + PyFunctionObject *init_func = (PyFunctionObject *)FT_ATOMIC_LOAD_PTR_ACQUIRE(cls->_spec_cache.init); + PyCodeObject *code = (PyCodeObject *)init_func->func_code; + if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(CALL, hit); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *self_o = PyType_GenericAlloc(tp, 0); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (self_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + self_or_null = PyStackRef_FromPyObjectSteal(self_o); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(init_func); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(temp); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _CREATE_INIT_FRAME_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *args; _PyStackRef self; + _PyStackRef init; + _PyStackRef init_frame; oparg = CURRENT_OPARG(); - owner = stack_pointer[-1]; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache1 = self; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; + args = &stack_pointer[-oparg]; + self = stack_pointer[-1 - oparg]; + init = stack_pointer[-2 - oparg]; + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( + tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); + stack_pointer = _PyFrame_GetStackPointer(frame); + assert(_PyFrame_GetBytecode(shim)[0].op.code == EXIT_INIT_CHECK); + assert(_PyFrame_GetBytecode(shim)[1].op.code == RETURN_VALUE); + shim->localsplus[0] = PyStackRef_DUP(self); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( + tstate, init, NULL, args-1, oparg+1, NULL, shim); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (temp == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyEval_FrameClearAndPop(tstate, shim); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL; + tstate->py_recursion_remaining--; + init_frame = PyStackRef_Wrap(temp); + _tos_cache0 = init_frame; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_LAZY_DICT_r12: { + case _EXIT_INIT_CHECK_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef self; + _PyStackRef should_be_none; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - owner = _stack_item_0; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache1 = self; - _tos_cache0 = attr; - SET_CURRENT_CACHED_VALUES(2); + should_be_none = _stack_item_0; + if (!PyStackRef_IsNone(should_be_none)) { + stack_pointer[0] = should_be_none; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyErr_Format(PyExc_TypeError, + "__init__() should return None, not '%.200s'", + Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_ATTR_METHOD_LAZY_DICT_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CALL_BUILTIN_CLASS_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef owner; - _PyStackRef attr; - _PyStackRef self; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef res; oparg = CURRENT_OPARG(); - owner = _stack_item_1; - PyObject *descr = (PyObject *)CURRENT_OPERAND0_64(); - assert(oparg & 1); - STAT_INC(LOAD_ATTR, hit); - assert(descr != NULL); - assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); - attr = PyStackRef_FromPyObjectNew(descr); - self = owner; - _tos_cache2 = self; - _tos_cache1 = attr; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (!PyType_Check(callable_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *tp = (PyTypeObject *)callable_o; + int total_args = oparg; + _PyStackRef *arguments = args; + if (!PyStackRef_IsNull(self_or_null)) { + arguments--; + total_args++; + } + if (tp->tp_vectorcall == NULL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(CALL, hit); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _Py_CallBuiltinClass_StackRefSteal( + callable, + arguments, + total_args); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MAYBE_EXPAND_METHOD_r00: { + case _CALL_BUILTIN_O_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *args; _PyStackRef self_or_null; _PyStackRef callable; + _PyStackRef res; + _PyStackRef c; + _PyStackRef s; oparg = CURRENT_OPARG(); + args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null = PyStackRef_FromPyObjectNew(self); - PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable; - callable = PyStackRef_FromPyObjectNew(method); - stack_pointer[-2 - oparg] = callable; - stack_pointer[-1 - oparg] = self_or_null; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(temp); - stack_pointer = _PyFrame_GetStackPointer(frame); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + int total_args = oparg; + if (!PyStackRef_IsNull(self_or_null)) { + args--; + total_args++; } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[-2 - oparg] = callable; - stack_pointer[-1 - oparg] = self_or_null; + if (total_args != 1) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + if (!PyCFunction_CheckExact(callable_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + if (PyCFunction_GET_FLAGS(callable_o) != METH_O) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + if (_Py_ReachedRecursionLimit(tstate)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(CALL, hit); + PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); + _PyStackRef arg = args[0]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); + stack_pointer = _PyFrame_GetStackPointer(frame); + _Py_LeaveRecursiveCallTstate(tstate); + assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + c = callable; + s = args[0]; + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache2 = s; + _tos_cache1 = c; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _DO_CALL is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ - - /* _MONITOR_CALL is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ - - case _PY_FRAME_GENERAL_r01: { + case _CALL_BUILTIN_FAST_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef *args; _PyStackRef self_or_null; _PyStackRef callable; - _PyStackRef new_frame; + _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; + _PyStackRef *arguments = args; if (!PyStackRef_IsNull(self_or_null)) { - args--; + arguments--; total_args++; } - assert(Py_TYPE(callable_o) == &PyFunction_Type); - int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags; - PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (!PyCFunction_CheckExact(callable_o)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + if (PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + STAT_INC(CALL, hit); _PyFrame_SetStackPointer(frame, stack_pointer); - _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, callable, locals, - args, total_args, NULL, frame + PyObject *res_o = _Py_BuiltinCallFast_StackRefSteal( + callable, + arguments, + total_args ); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (temp == NULL) { + if (res_o == NULL) { + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - new_frame = PyStackRef_Wrap(temp); - _tos_cache0 = new_frame; + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_FUNCTION_VERSION_r00: { + case _CALL_BUILTIN_FAST_WITH_KEYWORDS_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef *args; + _PyStackRef self_or_null; _PyStackRef callable; + _PyStackRef res; oparg = CURRENT_OPARG(); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + int total_args = oparg; + _PyStackRef *arguments = args; + if (!PyStackRef_IsNull(self_or_null)) { + arguments--; + total_args++; + } PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (!PyFunction_Check(callable_o)) { + if (!PyCFunction_CheckExact(callable_o)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - PyFunctionObject *func = (PyFunctionObject *)callable_o; - if (func->func_version != func_version) { + if (PyCFunction_GET_FLAGS(callable_o) != (METH_FASTCALL | METH_KEYWORDS)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + STAT_INC(CALL, hit); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _Py_BuiltinCallFastWithKeywords_StackRefSteal(callable, arguments, total_args); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_FUNCTION_VERSION_INLINE_r00: { + case _GUARD_CALLABLE_LEN_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); - assert(PyFunction_Check(callable_o)); - PyFunctionObject *func = (PyFunctionObject *)callable_o; - if (func->func_version != func_version) { + _PyStackRef callable; + callable = stack_pointer[-3]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.len) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_FUNCTION_VERSION_INLINE_r11: { + case _GUARD_CALLABLE_LEN_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); - assert(PyFunction_Check(callable_o)); - PyFunctionObject *func = (PyFunctionObject *)callable_o; - if (func->func_version != func_version) { + callable = stack_pointer[-2]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.len) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_FUNCTION_VERSION_INLINE_r22: { + case _GUARD_CALLABLE_LEN_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); - assert(PyFunction_Check(callable_o)); - PyFunctionObject *func = (PyFunctionObject *)callable_o; - if (func->func_version != func_version) { + callable = stack_pointer[-1]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.len) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_FUNCTION_VERSION_INLINE_r33: { + case _GUARD_CALLABLE_LEN_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *callable_o = (PyObject *)CURRENT_OPERAND1_64(); - assert(PyFunction_Check(callable_o)); - PyFunctionObject *func = (PyFunctionObject *)callable_o; - if (func->func_version != func_version) { + callable = _stack_item_0; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.len) { UOP_STAT_INC(uopcode, miss); _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + _tos_cache0 = callable; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + _tos_cache0 = callable; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_METHOD_VERSION_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_LEN_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; _PyStackRef callable; - oparg = CURRENT_OPARG(); - null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + callable = _stack_item_1; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (Py_TYPE(callable_o) != &PyMethod_Type) { + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.len) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - PyObject *func = ((PyMethodObject *)callable_o)->im_func; - if (!PyFunction_Check(func)) { + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CALLABLE_LEN_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + callable = _stack_item_2; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.len) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - if (((PyFunctionObject *)func)->func_version != func_version) { + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CALL_LEN_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef callable; + _PyStackRef res; + _PyStackRef a; + _PyStackRef c; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + arg = _stack_item_2; + callable = _stack_item_0; + STAT_INC(CALL, hit); + PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); + stack_pointer[0] = callable; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = arg; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_ssize_t len_i = PyObject_Length(arg_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (len_i < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + PyObject *res_o = PyLong_FromSsize_t(len_i); + assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + a = arg; + c = callable; + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache2 = c; + _tos_cache1 = a; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CALLABLE_ISINSTANCE_r04: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; + callable = stack_pointer[-4]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.isinstance) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - if (!PyStackRef_IsNull(null)) { + _tos_cache3 = stack_pointer[-1]; + _tos_cache2 = stack_pointer[-2]; + _tos_cache1 = stack_pointer[-3]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CALLABLE_ISINSTANCE_r14: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + callable = stack_pointer[-3]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.isinstance) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = _stack_item_0; + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _EXPAND_METHOD_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_ISINSTANCE_r24: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self_or_null; _PyStackRef callable; - oparg = CURRENT_OPARG(); - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + callable = stack_pointer[-2]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - assert(PyStackRef_IsNull(self_or_null)); - assert(Py_TYPE(callable_o) == &PyMethod_Type); - self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - _PyStackRef temp = callable; - callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(callable)); - stack_pointer[-2 - oparg] = callable; - stack_pointer[-1 - oparg] = self_or_null; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(temp); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.isinstance) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_1; + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_IS_NOT_PY_CALLABLE_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_ISINSTANCE_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef callable; - oparg = CURRENT_OPARG(); - callable = stack_pointer[-2 - oparg]; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + callable = stack_pointer[-1]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (PyFunction_Check(callable_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (Py_TYPE(callable_o) == &PyMethod_Type) { + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.isinstance) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = _stack_item_2; + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_NON_PY_GENERAL_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_ISINSTANCE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; _PyStackRef callable; - _PyStackRef res; - oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - #if TIER_ONE - assert(opcode != INSTRUMENTED_CALL); - #endif - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; - } - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _Py_VectorCall_StackRefSteal( - callable, - arguments, - total_args, - PyStackRef_NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + callable = _stack_item_0; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.isinstance) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_ISINSTANCE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; _PyStackRef callable; - oparg = CURRENT_OPARG(); - null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - if (!PyStackRef_IsNull(null)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type) { + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + callable = _stack_item_1; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.isinstance) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _CALL_ISINSTANCE_r41: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self_or_null; + _PyStackRef cls; + _PyStackRef instance; + _PyStackRef null; _PyStackRef callable; - oparg = CURRENT_OPARG(); - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - assert(PyStackRef_IsNull(self_or_null)); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + cls = _stack_item_3; + instance = _stack_item_2; + null = _stack_item_1; + callable = _stack_item_0; STAT_INC(CALL, hit); - self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - _PyStackRef temp = callable; - callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - stack_pointer[-2 - oparg] = callable; - stack_pointer[-1 - oparg] = self_or_null; + PyObject *inst_o = PyStackRef_AsPyObjectBorrow(instance); + PyObject *cls_o = PyStackRef_AsPyObjectBorrow(cls); + stack_pointer[0] = callable; + stack_pointer[1] = null; + stack_pointer[2] = instance; + stack_pointer[3] = cls; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(temp); + int retval = PyObject_IsInstance(inst_o, cls_o); stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; + if (retval < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + (void)null; + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(cls); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(instance); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callable); + stack_pointer = _PyFrame_GetStackPointer(frame); + res = retval ? PyStackRef_True : PyStackRef_False; + assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_PEP_523_r00: { + case _GUARD_CALLABLE_LIST_APPEND_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - if (IS_PEP523_HOOKED(tstate)) { + _PyStackRef callable; + callable = stack_pointer[-3]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.list_append) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_PEP_523_r11: { + case _GUARD_CALLABLE_LIST_APPEND_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - if (IS_PEP523_HOOKED(tstate)) { + callable = stack_pointer[-2]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.list_append) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_PEP_523_r22: { + case _GUARD_CALLABLE_LIST_APPEND_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - if (IS_PEP523_HOOKED(tstate)) { + callable = stack_pointer[-1]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.list_append) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = callable; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_PEP_523_r33: { + case _GUARD_CALLABLE_LIST_APPEND_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - if (IS_PEP523_HOOKED(tstate)) { + callable = _stack_item_0; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.list_append) { UOP_STAT_INC(uopcode, miss); _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + _tos_cache0 = callable; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + _tos_cache0 = callable; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_FUNCTION_EXACT_ARGS_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_LIST_APPEND_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self_or_null; _PyStackRef callable; - oparg = CURRENT_OPARG(); - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + callable = _stack_item_1; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - assert(PyFunction_Check(callable_o)); - PyFunctionObject *func = (PyFunctionObject *)callable_o; - PyCodeObject *code = (PyCodeObject *)func->func_code; - if (code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null))) { + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.list_append) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = callable; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_STACK_SPACE_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_CALLABLE_LIST_APPEND_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef callable; - oparg = CURRENT_OPARG(); - callable = stack_pointer[-2 - oparg]; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + callable = _stack_item_2; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyFunctionObject *func = (PyFunctionObject *)callable_o; - PyCodeObject *code = (PyCodeObject *)func->func_code; - if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { + PyInterpreterState *interp = tstate->interp; + if (callable_o != interp->callable_cache.list_append) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = callable; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_RECURSION_REMAINING_r00: { + case _CALL_LIST_APPEND_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - if (tstate->py_recursion_remaining <= 1) { + _PyStackRef arg; + _PyStackRef self; + _PyStackRef callable; + _PyStackRef none; + _PyStackRef c; + _PyStackRef s; + oparg = CURRENT_OPARG(); + arg = stack_pointer[-1]; + self = stack_pointer[-2]; + callable = stack_pointer[-3]; + assert(oparg == 1); + PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); + if (!LOCK_OBJECT(self_o)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + STAT_INC(CALL, hit); + int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); + UNLOCK_OBJECT(self_o); + if (err) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + c = callable; + s = self; + none = PyStackRef_None; + _tos_cache2 = s; + _tos_cache1 = c; + _tos_cache0 = none; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_RECURSION_REMAINING_r11: { + case _CALL_LIST_APPEND_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef self; + _PyStackRef callable; + _PyStackRef none; + _PyStackRef c; + _PyStackRef s; _PyStackRef _stack_item_0 = _tos_cache0; - if (tstate->py_recursion_remaining <= 1) { + oparg = CURRENT_OPARG(); + arg = _stack_item_0; + self = stack_pointer[-1]; + callable = stack_pointer[-2]; + assert(oparg == 1); + PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); + if (!LOCK_OBJECT(self_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; + _tos_cache0 = arg; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + STAT_INC(CALL, hit); + int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); + UNLOCK_OBJECT(self_o); + if (err) { + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + c = callable; + s = self; + none = PyStackRef_None; + _tos_cache2 = s; + _tos_cache1 = c; + _tos_cache0 = none; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_RECURSION_REMAINING_r22: { + case _CALL_LIST_APPEND_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef self; + _PyStackRef callable; + _PyStackRef none; + _PyStackRef c; + _PyStackRef s; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - if (tstate->py_recursion_remaining <= 1) { + oparg = CURRENT_OPARG(); + arg = _stack_item_1; + self = _stack_item_0; + callable = stack_pointer[-1]; + assert(oparg == 1); + PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); + if (!LOCK_OBJECT(self_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + _tos_cache1 = arg; + _tos_cache0 = self; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + STAT_INC(CALL, hit); + int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); + UNLOCK_OBJECT(self_o); + if (err) { + stack_pointer[0] = self; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + c = callable; + s = self; + none = PyStackRef_None; + _tos_cache2 = s; + _tos_cache1 = c; + _tos_cache0 = none; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_RECURSION_REMAINING_r33: { + case _CALL_LIST_APPEND_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef self; + _PyStackRef callable; + _PyStackRef none; + _PyStackRef c; + _PyStackRef s; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - if (tstate->py_recursion_remaining <= 1) { + oparg = CURRENT_OPARG(); + arg = _stack_item_2; + self = _stack_item_1; + callable = _stack_item_0; + assert(oparg == 1); + PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); + if (!LOCK_OBJECT(self_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + _tos_cache2 = arg; + _tos_cache1 = self; + _tos_cache0 = callable; SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _INIT_CALL_PY_EXACT_ARGS_0_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef new_frame; - oparg = 0; - assert(oparg == CURRENT_OPARG()); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); - _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; - pushed_frame->localsplus[0] = self_or_null; - for (int i = 0; i < oparg; i++) { - first_non_self_local[i] = args[i]; + int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); + UNLOCK_OBJECT(self_o); + if (err) { + stack_pointer[0] = callable; + stack_pointer[1] = self; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + c = callable; + s = self; + none = PyStackRef_None; + _tos_cache2 = s; + _tos_cache1 = c; + _tos_cache0 = none; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INIT_CALL_PY_EXACT_ARGS_1_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _CALL_LIST_APPEND_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; + _PyStackRef arg; + _PyStackRef self; _PyStackRef callable; - _PyStackRef new_frame; - oparg = 1; - assert(oparg == CURRENT_OPARG()); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - int has_self = !PyStackRef_IsNull(self_or_null); + _PyStackRef none; + _PyStackRef c; + _PyStackRef s; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + arg = _stack_item_3; + self = _stack_item_2; + callable = _stack_item_1; + assert(oparg == 1); + PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); + if (!LOCK_OBJECT(self_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = arg; + _tos_cache2 = self; + _tos_cache1 = callable; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } STAT_INC(CALL, hit); - _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); - _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; - pushed_frame->localsplus[0] = self_or_null; - for (int i = 0; i < oparg; i++) { - first_non_self_local[i] = args[i]; + int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); + UNLOCK_OBJECT(self_o); + if (err) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = callable; + stack_pointer[2] = self; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + c = callable; + s = self; + none = PyStackRef_None; + _tos_cache3 = s; + _tos_cache2 = c; + _tos_cache1 = none; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INIT_CALL_PY_EXACT_ARGS_2_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _CALL_LIST_APPEND_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; + _PyStackRef arg; + _PyStackRef self; _PyStackRef callable; - _PyStackRef new_frame; - oparg = 2; - assert(oparg == CURRENT_OPARG()); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - int has_self = !PyStackRef_IsNull(self_or_null); + _PyStackRef none; + _PyStackRef c; + _PyStackRef s; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = CURRENT_OPARG(); + arg = _stack_item_4; + self = _stack_item_3; + callable = _stack_item_2; + assert(oparg == 1); + PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); + if (!LOCK_OBJECT(self_o)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = arg; + _tos_cache3 = self; + _tos_cache2 = callable; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } STAT_INC(CALL, hit); - _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); - _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; - pushed_frame->localsplus[0] = self_or_null; - for (int i = 0; i < oparg; i++) { - first_non_self_local[i] = args[i]; + int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); + UNLOCK_OBJECT(self_o); + if (err) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = callable; + stack_pointer[3] = self; + stack_pointer += 5; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + c = callable; + s = self; + none = PyStackRef_None; + _tos_cache4 = s; + _tos_cache3 = c; + _tos_cache2 = none; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INIT_CALL_PY_EXACT_ARGS_3_r01: { + case _CALL_METHOD_DESCRIPTOR_O_r04: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef *args; _PyStackRef self_or_null; _PyStackRef callable; - _PyStackRef new_frame; - oparg = 3; - assert(oparg == CURRENT_OPARG()); + _PyStackRef res; + _PyStackRef c; + _PyStackRef s; + _PyStackRef a; + oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - int has_self = !PyStackRef_IsNull(self_or_null); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + int total_args = oparg; + _PyStackRef *arguments = args; + if (!PyStackRef_IsNull(self_or_null)) { + arguments--; + total_args++; + } + PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o; + if (total_args != 2) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + if (!Py_IS_TYPE(method, &PyMethodDescr_Type)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyMethodDef *meth = method->d_method; + if (meth->ml_flags != METH_O) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + if (_Py_ReachedRecursionLimit(tstate)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _PyStackRef arg_stackref = arguments[1]; + _PyStackRef self_stackref = arguments[0]; + if (!Py_IS_TYPE(PyStackRef_AsPyObjectBorrow(self_stackref), + method->d_common.d_type)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } STAT_INC(CALL, hit); - _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); - _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; - pushed_frame->localsplus[0] = self_or_null; - for (int i = 0; i < oparg; i++) { - first_non_self_local[i] = args[i]; + PyCFunction cfunc = meth->ml_meth; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, + PyStackRef_AsPyObjectBorrow(self_stackref), + PyStackRef_AsPyObjectBorrow(arg_stackref)); + stack_pointer = _PyFrame_GetStackPointer(frame); + _Py_LeaveRecursiveCallTstate(tstate); + assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; - SET_CURRENT_CACHED_VALUES(1); + c = callable; + s = arguments[0]; + a = arguments[1]; + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache3 = a; + _tos_cache2 = s; + _tos_cache1 = c; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INIT_CALL_PY_EXACT_ARGS_4_r01: { + case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef *args; _PyStackRef self_or_null; _PyStackRef callable; - _PyStackRef new_frame; - oparg = 4; - assert(oparg == CURRENT_OPARG()); + _PyStackRef res; + oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - int has_self = !PyStackRef_IsNull(self_or_null); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + int total_args = oparg; + _PyStackRef *arguments = args; + if (!PyStackRef_IsNull(self_or_null)) { + arguments--; + total_args++; + } + if (total_args == 0) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o; + if (!Py_IS_TYPE(method, &PyMethodDescr_Type)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyMethodDef *meth = method->d_method; + if (meth->ml_flags != (METH_FASTCALL|METH_KEYWORDS)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyTypeObject *d_type = method->d_common.d_type; + PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]); + assert(self != NULL); + if (!Py_IS_TYPE(self, d_type)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } STAT_INC(CALL, hit); - _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); - _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; - pushed_frame->localsplus[0] = self_or_null; - for (int i = 0; i < oparg; i++) { - first_non_self_local[i] = args[i]; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyCallMethodDescriptorFastWithKeywords_StackRefSteal( + callable, + meth, + self, + arguments, + total_args + ); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); } - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(1); stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INIT_CALL_PY_EXACT_ARGS_r01: { + case _CALL_METHOD_DESCRIPTOR_NOARGS_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef *args; _PyStackRef self_or_null; _PyStackRef callable; - _PyStackRef new_frame; + _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - int has_self = !PyStackRef_IsNull(self_or_null); - STAT_INC(CALL, hit); - _PyInterpreterFrame *pushed_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); - _PyStackRef *first_non_self_local = pushed_frame->localsplus + has_self; - pushed_frame->localsplus[0] = self_or_null; - for (int i = 0; i < oparg; i++) { - first_non_self_local[i] = args[i]; + assert(oparg == 0 || oparg == 1); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + int total_args = oparg; + if (!PyStackRef_IsNull(self_or_null)) { + args--; + total_args++; } - new_frame = PyStackRef_Wrap(pushed_frame); - _tos_cache0 = new_frame; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _PUSH_FRAME_r10: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef new_frame; - _PyStackRef _stack_item_0 = _tos_cache0; - new_frame = _stack_item_0; - assert(!IS_PEP523_HOOKED(tstate)); - _PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame); - _PyFrame_SetStackPointer(frame, stack_pointer); - assert(temp->previous == frame || temp->previous->previous == frame); - CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = temp; - tstate->py_recursion_remaining--; - LOAD_SP(); - LOAD_IP(0); - LLTRACE_RESUME_FRAME(); - SET_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_NULL_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - null = stack_pointer[-2]; - if (!PyStackRef_IsNull(null)) { + if (total_args != 1) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_NULL_r12: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - _PyStackRef _stack_item_0 = _tos_cache0; - null = stack_pointer[-1]; - if (!PyStackRef_IsNull(null)) { + PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o; + if (!Py_IS_TYPE(method, &PyMethodDescr_Type)) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_0; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_NULL_r22: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - null = _stack_item_0; - if (!PyStackRef_IsNull(null)) { + PyMethodDef *meth = method->d_method; + _PyStackRef self_stackref = args[0]; + PyObject *self = PyStackRef_AsPyObjectBorrow(self_stackref); + if (!Py_IS_TYPE(self, method->d_common.d_type)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_1; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_NULL_r33: { - CHECK_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - null = _stack_item_1; - if (!PyStackRef_IsNull(null)) { + if (meth->ml_flags != METH_NOARGS) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = null; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_2; - _tos_cache1 = null; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_NOT_NULL_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - nos = stack_pointer[-2]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (o == NULL) { + if (_Py_ReachedRecursionLimit(tstate)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; + STAT_INC(CALL, hit); + PyCFunction cfunc = meth->ml_meth; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); + _Py_LeaveRecursiveCallTstate(tstate); + assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(self_stackref); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callable); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_NOT_NULL_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CALL_METHOD_DESCRIPTOR_FAST_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - _PyStackRef _stack_item_0 = _tos_cache0; - nos = stack_pointer[-1]; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (o == NULL) { + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef res; + oparg = CURRENT_OPARG(); + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + int total_args = oparg; + _PyStackRef *arguments = args; + if (!PyStackRef_IsNull(self_or_null)) { + arguments--; + total_args++; + } + if (total_args == 0) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_0; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_NOS_NOT_NULL_r22: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - nos = _stack_item_0; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (o == NULL) { + PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o; + if (!Py_IS_TYPE(method, &PyMethodDescr_Type)) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyMethodDef *meth = method->d_method; + if (meth->ml_flags != METH_FASTCALL) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]); + assert(self != NULL); + if (!Py_IS_TYPE(self, method->d_common.d_type)) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache1 = _stack_item_1; - _tos_cache0 = nos; - SET_CURRENT_CACHED_VALUES(2); + STAT_INC(CALL, hit); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _PyCallMethodDescriptorFast_StackRefSteal( + callable, + meth, + self, + arguments, + total_args + ); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_NOS_NOT_NULL_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + /* _MONITOR_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ + + case _MAYBE_EXPAND_METHOD_KW_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef nos; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - nos = _stack_item_1; - PyObject *o = PyStackRef_AsPyObjectBorrow(nos); - if (o == NULL) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); + oparg = CURRENT_OPARG(); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + self_or_null = PyStackRef_FromPyObjectNew(self); + PyObject *method = ((PyMethodObject *)callable_o)->im_func; + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(temp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; } - _tos_cache2 = _stack_item_2; - _tos_cache1 = nos; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_THIRD_NULL_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + /* _DO_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ + + case _PY_FRAME_KW_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - null = stack_pointer[-3]; - if (!PyStackRef_IsNull(null)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + _PyStackRef kwnames; + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; + _PyStackRef new_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + kwnames = _stack_item_0; + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + int total_args = oparg; + _PyStackRef *arguments = args; + if (!PyStackRef_IsNull(self_or_null)) { + arguments--; + total_args++; } - _tos_cache2 = stack_pointer[-1]; - _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; + PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); + int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); + assert(Py_TYPE(callable_o) == &PyFunction_Type); + int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags; + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); + stack_pointer[0] = kwnames; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( + tstate, callable, locals, + arguments, positional_args, kwnames_o, frame + ); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(kwnames); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (temp == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + new_frame = PyStackRef_Wrap(temp); + _tos_cache0 = new_frame; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_THIRD_NULL_r13: { + case _CHECK_FUNCTION_VERSION_KW_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - null = stack_pointer[-2]; - if (!PyStackRef_IsNull(null)) { + oparg = CURRENT_OPARG(); + callable = stack_pointer[-2 - oparg]; + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (!PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_0; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_THIRD_NULL_r23: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - null = stack_pointer[-1]; - if (!PyStackRef_IsNull(null)) { + PyFunctionObject *func = (PyFunctionObject *)callable_o; + if (func->func_version != func_version) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_1; - _tos_cache1 = _stack_item_0; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_THIRD_NULL_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_METHOD_VERSION_KW_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef null; + _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - null = _stack_item_0; - if (!PyStackRef_IsNull(null)) { + oparg = CURRENT_OPARG(); + null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (Py_TYPE(callable_o) != &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = null; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_CALLABLE_TYPE_1_r03: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; - callable = stack_pointer[-3]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyType_Type) { + PyObject *func = ((PyMethodObject *)callable_o)->im_func; + if (!PyFunction_Check(func)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = stack_pointer[-1]; - _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_CALLABLE_TYPE_1_r13: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; - _PyStackRef _stack_item_0 = _tos_cache0; - callable = stack_pointer[-2]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyType_Type) { + if (((PyFunctionObject *)func)->func_version != func_version) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_0; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (!PyStackRef_IsNull(null)) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_TYPE_1_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _EXPAND_METHOD_KW_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef self_or_null; _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - callable = stack_pointer[-1]; + oparg = CURRENT_OPARG(); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + assert(PyStackRef_IsNull(self_or_null)); + _PyStackRef callable_s = callable; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyType_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_1; - _tos_cache1 = _stack_item_0; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + assert(Py_TYPE(callable_o) == &PyMethod_Type); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(callable)); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callable_s); + stack_pointer = _PyFrame_GetStackPointer(frame); + _tos_cache0 = _stack_item_0; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_TYPE_1_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_IS_NOT_PY_CALLABLE_KW_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef callable; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - callable = _stack_item_0; + oparg = CURRENT_OPARG(); + callable = stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyType_Type) { + if (PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _CALL_TYPE_1_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; - oparg = CURRENT_OPARG(); - arg = stack_pointer[-1]; - PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); - assert(oparg == 1); - STAT_INC(CALL, hit); - a = arg; - res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (Py_TYPE(callable_o) == &PyMethod_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_TYPE_1_r12: { + case _CALL_KW_NON_PY_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; + _PyStackRef kwnames; + _PyStackRef *args; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; - _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; oparg = CURRENT_OPARG(); - arg = _stack_item_0; - PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); - assert(oparg == 1); - STAT_INC(CALL, hit); - a = arg; - res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); - _tos_cache1 = a; + kwnames = _stack_item_0; + args = &stack_pointer[-oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + #if TIER_ONE + assert(opcode != INSTRUMENTED_CALL); + #endif + int total_args = oparg; + _PyStackRef *arguments = args; + if (!PyStackRef_IsNull(self_or_null)) { + arguments--; + total_args++; + } + stack_pointer[0] = kwnames; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = _Py_VectorCall_StackRefSteal( + callable, + arguments, + total_args, + kwnames); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + stack_pointer += -3 - oparg; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -3 - oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_TYPE_1_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _MAKE_CALLARGS_A_TUPLE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; + _PyStackRef callargs; + _PyStackRef func; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - arg = _stack_item_1; - PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); - assert(oparg == 1); - STAT_INC(CALL, hit); - a = arg; - res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + callargs = _stack_item_2; + func = _stack_item_0; + PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs); + if (!PyTuple_CheckExact(callargs_o)) { + stack_pointer[0] = func; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = callargs; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *tuple_o = PySequence_Tuple(callargs_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (tuple_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + _PyStackRef temp = callargs; + callargs = PyStackRef_FromPyObjectSteal(tuple_o); + stack_pointer[-2] = callargs; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(temp); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -4; + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = callargs; + _tos_cache1 = _stack_item_1; + _tos_cache0 = func; + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_TYPE_1_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + /* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ + + case _CHECK_IS_PY_CALLABLE_EX_r04: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - arg = _stack_item_2; - PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); - assert(oparg == 1); - STAT_INC(CALL, hit); - a = arg; - res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o)); - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef func_st; + func_st = stack_pointer[-4]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) != &PyFunction_Type) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = stack_pointer[-1]; + _tos_cache2 = stack_pointer[-2]; + _tos_cache1 = stack_pointer[-3]; + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_STR_1_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _CHECK_IS_PY_CALLABLE_EX_r14: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; - callable = stack_pointer[-3]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyUnicode_Type) { + _PyStackRef func_st; + _PyStackRef _stack_item_0 = _tos_cache0; + func_st = stack_pointer[-3]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) != &PyFunction_Type) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_0; _tos_cache2 = stack_pointer[-1]; _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_STR_1_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CHECK_IS_PY_CALLABLE_EX_r24: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef func_st; _PyStackRef _stack_item_0 = _tos_cache0; - callable = stack_pointer[-2]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyUnicode_Type) { + _PyStackRef _stack_item_1 = _tos_cache1; + func_st = stack_pointer[-2]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) != &PyFunction_Type) { UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_1; _tos_cache2 = _stack_item_0; _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_STR_1_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_IS_PY_CALLABLE_EX_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef func_st; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - callable = stack_pointer[-1]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyUnicode_Type) { + _PyStackRef _stack_item_2 = _tos_cache2; + func_st = stack_pointer[-1]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) != &PyFunction_Type) { UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_2; _tos_cache2 = _stack_item_1; _tos_cache1 = _stack_item_0; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_STR_1_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_IS_PY_CALLABLE_EX_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef func_st; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - callable = _stack_item_0; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyUnicode_Type) { + _PyStackRef _stack_item_3 = _tos_cache3; + func_st = _stack_item_0; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) != &PyFunction_Type) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_STR_1_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_IS_PY_CALLABLE_EX_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; + _PyStackRef func_st; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - arg = _stack_item_2; - PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); - assert(oparg == 1); - STAT_INC(CALL, hit); - stack_pointer[0] = _stack_item_0; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + func_st = _stack_item_1; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) != &PyFunction_Type) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = func_st; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = func_st; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = func_st; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _PY_FRAME_EX_r41: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef kwargs_st; + _PyStackRef callargs_st; + _PyStackRef func_st; + _PyStackRef ex_frame; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + kwargs_st = _stack_item_3; + callargs_st = _stack_item_2; + func_st = _stack_item_0; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + PyObject *callargs = PyStackRef_AsPyObjectSteal(callargs_st); + assert(PyTuple_CheckExact(callargs)); + assert(Py_TYPE(func) == &PyFunction_Type); + assert(((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall); + PyObject *kwargs = PyStackRef_IsNull(kwargs_st) ? NULL : PyStackRef_AsPyObjectSteal(kwargs_st); + assert(kwargs == NULL || PyDict_CheckExact(kwargs)); + Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); + int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); + stack_pointer[0] = func_st; stack_pointer[1] = _stack_item_1; - stack_pointer[2] = arg; - stack_pointer += 3; + stack_pointer += 2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = PyObject_Str(arg_o); + _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex( + tstate, func_st, locals, + nargs, callargs, kwargs, frame); stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (new_frame == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - a = arg; - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache1 = a; - _tos_cache0 = res; + ex_frame = PyStackRef_Wrap(new_frame); + _tos_cache0 = ex_frame; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_TUPLE_1_r03: { + case _CHECK_IS_NOT_PY_CALLABLE_EX_r04: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; - callable = stack_pointer[-3]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyTuple_Type) { + _PyStackRef func_st; + func_st = stack_pointer[-4]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = stack_pointer[-1]; + _tos_cache2 = stack_pointer[-2]; + _tos_cache1 = stack_pointer[-3]; + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_IS_NOT_PY_CALLABLE_EX_r14: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef func_st; + _PyStackRef _stack_item_0 = _tos_cache0; + func_st = stack_pointer[-3]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_0; _tos_cache2 = stack_pointer[-1]; _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_TUPLE_1_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CHECK_IS_NOT_PY_CALLABLE_EX_r24: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef func_st; _PyStackRef _stack_item_0 = _tos_cache0; - callable = stack_pointer[-2]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyTuple_Type) { + _PyStackRef _stack_item_1 = _tos_cache1; + func_st = stack_pointer[-2]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_1; _tos_cache2 = _stack_item_0; _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_TUPLE_1_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_IS_NOT_PY_CALLABLE_EX_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef func_st; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - callable = stack_pointer[-1]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyTuple_Type) { + _PyStackRef _stack_item_2 = _tos_cache2; + func_st = stack_pointer[-1]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_2; + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _CHECK_IS_NOT_PY_CALLABLE_EX_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef func_st; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + func_st = _stack_item_0; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_1; - _tos_cache1 = _stack_item_0; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = func_st; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_TUPLE_1_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_IS_NOT_PY_CALLABLE_EX_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef func_st; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - callable = _stack_item_0; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (callable_o != (PyObject *)&PyTuple_Type) { + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + func_st = _stack_item_1; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache1 = func_st; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache1 = func_st; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_TUPLE_1_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CALL_FUNCTION_EX_NON_PY_GENERAL_r41: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; + _PyStackRef kwargs_st; + _PyStackRef callargs_st; + _PyStackRef null; + _PyStackRef func_st; + _PyStackRef result; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - arg = _stack_item_2; - PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); - assert(oparg == 1); - STAT_INC(CALL, hit); - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer[2] = arg; - stack_pointer += 3; + _PyStackRef _stack_item_3 = _tos_cache3; + kwargs_st = _stack_item_3; + callargs_st = _stack_item_2; + null = _stack_item_1; + func_st = _stack_item_0; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); + (void)null; + assert(PyTuple_CheckExact(callargs)); + PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st); + assert(kwargs == NULL || PyDict_CheckExact(kwargs)); + stack_pointer[0] = func_st; + stack_pointer[1] = null; + stack_pointer[2] = callargs_st; + stack_pointer[3] = kwargs_st; + stack_pointer += 4; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = PySequence_Tuple(arg_o); + PyObject *result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_XCLOSE(kwargs_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callargs_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(func_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (result_o == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - a = arg; - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache1 = a; - _tos_cache0 = res; + result = PyStackRef_FromPyObjectSteal(result_o); + _tos_cache0 = result; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_AND_ALLOCATE_OBJECT_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _MAKE_FUNCTION_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self_or_null; - _PyStackRef callable; - oparg = CURRENT_OPARG(); - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - uint32_t type_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (!PyStackRef_IsNull(self_or_null)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (!PyType_Check(callable_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyTypeObject *tp = (PyTypeObject *)callable_o; - if (FT_ATOMIC_LOAD_UINT32_RELAXED(tp->tp_version_tag) != type_version) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - assert(tp->tp_new == PyBaseObject_Type.tp_new); - assert(tp->tp_flags & Py_TPFLAGS_HEAPTYPE); - assert(tp->tp_alloc == PyType_GenericAlloc); - PyHeapTypeObject *cls = (PyHeapTypeObject *)callable_o; - PyFunctionObject *init_func = (PyFunctionObject *)FT_ATOMIC_LOAD_PTR_ACQUIRE(cls->_spec_cache.init); - PyCodeObject *code = (PyCodeObject *)init_func->func_code; - if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); + _PyStackRef codeobj_st; + _PyStackRef func; + _PyStackRef _stack_item_0 = _tos_cache0; + codeobj_st = _stack_item_0; + PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); + stack_pointer[0] = codeobj_st; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *self_o = PyType_GenericAlloc(tp, 0); + PyFunctionObject *func_obj = (PyFunctionObject *) + PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); - if (self_o == NULL) { + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(codeobj_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (func_obj == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - self_or_null = PyStackRef_FromPyObjectSteal(self_o); - _PyStackRef temp = callable; - callable = PyStackRef_FromPyObjectNew(init_func); - stack_pointer[-2 - oparg] = callable; - stack_pointer[-1 - oparg] = self_or_null; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(temp); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; + _PyFunction_SetVersion( + func_obj, ((PyCodeObject *)codeobj)->co_version); + func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); + _tos_cache0 = func; + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SET_FUNCTION_ATTRIBUTE_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef func_in; + _PyStackRef attr_st; + _PyStackRef func_out; + oparg = CURRENT_OPARG(); + func_in = stack_pointer[-1]; + attr_st = stack_pointer[-2]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); + func_out = func_in; + assert(PyFunction_Check(func)); + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; + _tos_cache0 = func_out; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SET_FUNCTION_ATTRIBUTE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef func_in; + _PyStackRef attr_st; + _PyStackRef func_out; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); + func_in = _stack_item_0; + attr_st = stack_pointer[-1]; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); + func_out = func_in; + assert(PyFunction_Check(func)); + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; + _tos_cache0 = func_out; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SET_FUNCTION_ATTRIBUTE_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef func_in; + _PyStackRef attr_st; + _PyStackRef func_out; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); + func_in = _stack_item_1; + attr_st = _stack_item_0; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); + func_out = func_in; + assert(PyFunction_Check(func)); + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; + _tos_cache0 = func_out; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SET_FUNCTION_ATTRIBUTE_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef func_in; + _PyStackRef attr_st; + _PyStackRef func_out; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + func_in = _stack_item_2; + attr_st = _stack_item_1; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); + func_out = func_in; + assert(PyFunction_Check(func)); + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; + _tos_cache1 = func_out; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CREATE_INIT_FRAME_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SET_FUNCTION_ATTRIBUTE_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self; - _PyStackRef init; - _PyStackRef init_frame; + _PyStackRef func_in; + _PyStackRef attr_st; + _PyStackRef func_out; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self = stack_pointer[-1 - oparg]; - init = stack_pointer[-2 - oparg]; - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( - tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); - stack_pointer = _PyFrame_GetStackPointer(frame); - assert(_PyFrame_GetBytecode(shim)[0].op.code == EXIT_INIT_CHECK); - assert(_PyFrame_GetBytecode(shim)[1].op.code == RETURN_VALUE); - shim->localsplus[0] = PyStackRef_DUP(self); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, init, NULL, args-1, oparg+1, NULL, shim); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (temp == NULL) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_FrameClearAndPop(tstate, shim); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL; - tstate->py_recursion_remaining--; - init_frame = PyStackRef_Wrap(temp); - _tos_cache0 = init_frame; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + func_in = _stack_item_3; + attr_st = _stack_item_2; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); + func_out = func_in; + assert(PyFunction_Check(func)); + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; + _tos_cache2 = func_out; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _EXIT_INIT_CHECK_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SET_FUNCTION_ATTRIBUTE_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef should_be_none; + _PyStackRef func_in; + _PyStackRef attr_st; + _PyStackRef func_out; _PyStackRef _stack_item_0 = _tos_cache0; - should_be_none = _stack_item_0; - if (!PyStackRef_IsNone(should_be_none)) { - stack_pointer[0] = should_be_none; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyErr_Format(PyExc_TypeError, - "__init__() should return None, not '%.200s'", - Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = CURRENT_OPARG(); + func_in = _stack_item_4; + attr_st = _stack_item_3; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); + func_out = func_in; + assert(PyFunction_Check(func)); + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; + _tos_cache3 = func_out; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_BUILTIN_CLASS_r01: { + case _RETURN_GENERATOR_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; _PyStackRef res; - oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (!PyType_Check(callable_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyTypeObject *tp = (PyTypeObject *)callable_o; - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; - } - if (tp->tp_vectorcall == NULL) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); + assert(PyStackRef_FunctionCheck(frame->f_funcobj)); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _Py_CallBuiltinClass_StackRefSteal( - callable, - arguments, - total_args); + PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (gen == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - res = PyStackRef_FromPyObjectSteal(res_o); + assert(STACK_LEVEL() <= 2); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyInterpreterFrame *gen_frame = &gen->gi_iframe; + frame->instr_ptr++; + _PyFrame_Copy(frame, gen_frame); + assert(frame->frame_obj == NULL); + gen->gi_frame_state = FRAME_CREATED; + gen_frame->owner = FRAME_OWNED_BY_GENERATOR; + _Py_LeaveRecursiveCallPy(tstate); + _PyInterpreterFrame *prev = frame->previous; + _PyThreadState_PopFrame(tstate, frame); + frame = tstate->current_frame = prev; + LOAD_IP(frame->return_offset); + stack_pointer = _PyFrame_GetStackPointer(frame); + res = PyStackRef_FromPyObjectStealMortal((PyObject *)gen); + LLTRACE_RESUME_FRAME(); _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_BUILTIN_O_r03: { + case _BUILD_SLICE_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef c; - _PyStackRef s; + _PyStackRef slice; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null)) { - args--; - total_args++; - } - if (total_args != 1) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (!PyCFunction_CheckExact(callable_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (PyCFunction_GET_FLAGS(callable_o) != METH_O) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (_Py_ReachedRecursionLimit(tstate)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); - PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); - _PyStackRef arg = args[0]; + PyObject *start_o = PyStackRef_AsPyObjectBorrow(args[0]); + PyObject *stop_o = PyStackRef_AsPyObjectBorrow(args[1]); + PyObject *step_o = oparg == 3 ? PyStackRef_AsPyObjectBorrow(args[2]) : NULL; + PyObject *slice_o = PySlice_New(start_o, stop_o, step_o); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); - stack_pointer = _PyFrame_GetStackPointer(frame); - _Py_LeaveRecursiveCallTstate(tstate); - assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef tmp; + for (int _i = oparg; --_i >= 0;) { + tmp = args[_i]; + args[_i] = PyStackRef_NULL; + PyStackRef_CLOSE(tmp); } - c = callable; - s = args[0]; - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache2 = s; - _tos_cache1 = c; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2 - oparg; + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -oparg; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + if (slice_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + slice = PyStackRef_FromPyObjectStealMortal(slice_o); + _tos_cache0 = slice; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_BUILTIN_FAST_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _CONVERT_VALUE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef res; + _PyStackRef value; + _PyStackRef result; + _PyStackRef _stack_item_0 = _tos_cache0; oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; - } - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (!PyCFunction_CheckExact(callable_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); + value = _stack_item_0; + conversion_func conv_fn; + assert(oparg >= FVC_STR && oparg <= FVC_ASCII); + conv_fn = _PyEval_ConversionFuncs[oparg]; + stack_pointer[0] = value; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _Py_BuiltinCallFast_StackRefSteal( - callable, - arguments, - total_args - ); + PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (result_o == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; + result = PyStackRef_FromPyObjectSteal(result_o); + _tos_cache0 = result; + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_BUILTIN_FAST_WITH_KEYWORDS_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _FORMAT_SIMPLE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; + _PyStackRef value; _PyStackRef res; - oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; - } - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (!PyCFunction_CheckExact(callable_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + _PyStackRef _stack_item_0 = _tos_cache0; + value = _stack_item_0; + PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); + if (!PyUnicode_CheckExact(value_o)) { + stack_pointer[0] = value; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *res_o = PyObject_Format(value_o, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(value); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (res_o == NULL) { + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_ERROR(); + } + res = PyStackRef_FromPyObjectSteal(res_o); } - if (PyCFunction_GET_FLAGS(callable_o) != (METH_FASTCALL | METH_KEYWORDS)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + else { + res = value; } - STAT_INC(CALL, hit); + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _FORMAT_WITH_SPEC_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef fmt_spec; + _PyStackRef value; + _PyStackRef res; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + fmt_spec = _stack_item_1; + value = _stack_item_0; + stack_pointer[0] = value; + stack_pointer[1] = fmt_spec; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _Py_BuiltinCallFastWithKeywords_StackRefSteal(callable, arguments, total_args); + PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); + _PyStackRef tmp = fmt_spec; + fmt_spec = PyStackRef_NULL; + stack_pointer[-1] = fmt_spec; + PyStackRef_CLOSE(tmp); + tmp = value; + value = PyStackRef_NULL; + stack_pointer[-2] = value; + PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); if (res_o == NULL) { - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } res = PyStackRef_FromPyObjectSteal(res_o); _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_1_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef bottom; + _PyStackRef top; + bottom = stack_pointer[-1]; + top = PyStackRef_DUP(bottom); + _tos_cache1 = top; + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_1_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef bottom; + _PyStackRef top; + _PyStackRef _stack_item_0 = _tos_cache0; + bottom = _stack_item_0; + top = PyStackRef_DUP(bottom); + _tos_cache1 = top; + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_1_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef bottom; + _PyStackRef top; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + bottom = _stack_item_1; + top = PyStackRef_DUP(bottom); + _tos_cache2 = top; + _tos_cache1 = bottom; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_1_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef bottom; + _PyStackRef top; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + bottom = _stack_item_2; + top = PyStackRef_DUP(bottom); + _tos_cache3 = top; + _tos_cache2 = bottom; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_1_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef bottom; + _PyStackRef top; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + bottom = _stack_item_3; + top = PyStackRef_DUP(bottom); + _tos_cache4 = top; + _tos_cache3 = bottom; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_LEN_r03: { + case _COPY_2_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; - callable = stack_pointer[-3]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.len) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = stack_pointer[-1]; - _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = callable; + _PyStackRef bottom; + _PyStackRef top; + bottom = stack_pointer[-2]; + top = PyStackRef_DUP(bottom); + _tos_cache2 = top; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = bottom; SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_LEN_r13: { + case _COPY_2_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef bottom; + _PyStackRef top; _PyStackRef _stack_item_0 = _tos_cache0; - callable = stack_pointer[-2]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.len) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_0; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = callable; + bottom = stack_pointer[-1]; + top = PyStackRef_DUP(bottom); + _tos_cache2 = top; + _tos_cache1 = _stack_item_0; + _tos_cache0 = bottom; SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_LEN_r23: { + case _COPY_2_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef bottom; + _PyStackRef top; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - callable = stack_pointer[-1]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.len) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_1; - _tos_cache1 = _stack_item_0; - _tos_cache0 = callable; + bottom = _stack_item_0; + top = PyStackRef_DUP(bottom); + _tos_cache2 = top; + _tos_cache1 = _stack_item_1; + _tos_cache0 = bottom; SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_LEN_r33: { + case _COPY_2_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef bottom; + _PyStackRef top; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - callable = _stack_item_0; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.len) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + bottom = _stack_item_1; + top = PyStackRef_DUP(bottom); + _tos_cache3 = top; _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache1 = bottom; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_LEN_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _COPY_2_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; + _PyStackRef bottom; + _PyStackRef top; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - arg = _stack_item_2; - callable = _stack_item_0; - STAT_INC(CALL, hit); - PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); - stack_pointer[0] = callable; - stack_pointer[1] = _stack_item_1; - stack_pointer[2] = arg; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_ssize_t len_i = PyObject_Length(arg_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (len_i < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - PyObject *res_o = PyLong_FromSsize_t(len_i); - assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - a = arg; - c = callable; - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_3 = _tos_cache3; + bottom = _stack_item_2; + top = PyStackRef_DUP(bottom); + _tos_cache4 = top; + _tos_cache3 = _stack_item_3; + _tos_cache2 = bottom; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_ISINSTANCE_r03: { + case _COPY_3_r04: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; - callable = stack_pointer[-4]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.isinstance) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef bottom; + _PyStackRef top; + bottom = stack_pointer[-3]; + top = PyStackRef_DUP(bottom); + _tos_cache3 = top; _tos_cache2 = stack_pointer[-1]; _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = stack_pointer[-3]; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_ISINSTANCE_r13: { + case _COPY_3_r14: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef bottom; + _PyStackRef top; _PyStackRef _stack_item_0 = _tos_cache0; - callable = stack_pointer[-3]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.isinstance) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + bottom = stack_pointer[-2]; + top = PyStackRef_DUP(bottom); + _tos_cache3 = top; _tos_cache2 = _stack_item_0; _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = stack_pointer[-2]; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_ISINSTANCE_r23: { + case _COPY_3_r24: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef bottom; + _PyStackRef top; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - callable = stack_pointer[-2]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.isinstance) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + bottom = stack_pointer[-1]; + top = PyStackRef_DUP(bottom); + _tos_cache3 = top; _tos_cache2 = _stack_item_1; _tos_cache1 = _stack_item_0; - _tos_cache0 = stack_pointer[-1]; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_ISINSTANCE_r33: { + case _COPY_3_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef bottom; + _PyStackRef top; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - callable = stack_pointer[-1]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.isinstance) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + bottom = _stack_item_0; + top = PyStackRef_DUP(bottom); + _tos_cache3 = top; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_3_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef bottom; + _PyStackRef top; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + bottom = _stack_item_1; + top = PyStackRef_DUP(bottom); + _tos_cache4 = top; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = bottom; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _COPY_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef bottom; + _PyStackRef top; + oparg = CURRENT_OPARG(); + bottom = stack_pointer[-1 - (oparg-1)]; + top = PyStackRef_DUP(bottom); + _tos_cache0 = top; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_ISINSTANCE_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _BINARY_OP_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef cls; - _PyStackRef instance; - _PyStackRef null; - _PyStackRef callable; + _PyStackRef rhs; + _PyStackRef lhs; _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - cls = _stack_item_2; - instance = _stack_item_1; - null = _stack_item_0; - callable = stack_pointer[-1]; - STAT_INC(CALL, hit); - PyObject *inst_o = PyStackRef_AsPyObjectBorrow(instance); - PyObject *cls_o = PyStackRef_AsPyObjectBorrow(cls); - stack_pointer[0] = null; - stack_pointer[1] = instance; - stack_pointer[2] = cls; - stack_pointer += 3; + oparg = CURRENT_OPARG(); + rhs = _stack_item_1; + lhs = _stack_item_0; + PyObject *lhs_o = PyStackRef_AsPyObjectBorrow(lhs); + PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs); + assert(_PyEval_BinaryOps[oparg]); + stack_pointer[0] = lhs; + stack_pointer[1] = rhs; + stack_pointer += 2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - int retval = PyObject_IsInstance(inst_o, cls_o); + PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (retval < 0) { + if (res_o == NULL) { SET_CURRENT_CACHED_VALUES(0); JUMP_TO_ERROR(); } - (void)null; - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(cls); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(instance); - stack_pointer = _PyFrame_GetStackPointer(frame); + res = PyStackRef_FromPyObjectSteal(res_o); + l = lhs; + r = rhs; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(3); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable); - stack_pointer = _PyFrame_GetStackPointer(frame); - res = retval ? PyStackRef_True : PyStackRef_False; - assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_LIST_APPEND_r03: { + case _SWAP_2_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; - callable = stack_pointer[-3]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.list_append) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = stack_pointer[-1]; - _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; + _PyStackRef top; + _PyStackRef bottom; + top = stack_pointer[-1]; + bottom = stack_pointer[-2]; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache1 = top; + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_LIST_APPEND_r13: { + case _SWAP_2_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef top; + _PyStackRef bottom; _PyStackRef _stack_item_0 = _tos_cache0; - callable = stack_pointer[-2]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.list_append) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_0; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + top = _stack_item_0; + bottom = stack_pointer[-1]; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache1 = top; + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_LIST_APPEND_r23: { + case _SWAP_2_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef top; + _PyStackRef bottom; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - callable = stack_pointer[-1]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.list_append) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_1; - _tos_cache1 = _stack_item_0; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + top = _stack_item_1; + bottom = _stack_item_0; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache1 = top; + _tos_cache0 = bottom; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CALLABLE_LIST_APPEND_r33: { + case _SWAP_2_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef top; + _PyStackRef bottom; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - callable = _stack_item_0; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyInterpreterState *interp = tstate->interp; - if (callable_o != interp->callable_cache.list_append) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = callable; + top = _stack_item_2; + bottom = _stack_item_1; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache2 = top; + _tos_cache1 = bottom; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_LIST_APPEND_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SWAP_2_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef self; - _PyStackRef callable; - _PyStackRef none; - _PyStackRef c; - _PyStackRef s; - oparg = CURRENT_OPARG(); - arg = stack_pointer[-1]; - self = stack_pointer[-2]; - callable = stack_pointer[-3]; - assert(oparg == 1); - PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); - if (!LOCK_OBJECT(self_o)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); - int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); - UNLOCK_OBJECT(self_o); - if (err) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - c = callable; - s = self; - none = PyStackRef_None; - _tos_cache2 = s; - _tos_cache1 = c; - _tos_cache0 = none; + _PyStackRef top; + _PyStackRef bottom; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + top = _stack_item_3; + bottom = _stack_item_2; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache3 = top; + _tos_cache2 = bottom; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SWAP_2_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef top; + _PyStackRef bottom; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + top = _stack_item_4; + bottom = _stack_item_3; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache4 = top; + _tos_cache3 = bottom; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SWAP_3_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef top; + _PyStackRef bottom; + top = stack_pointer[-1]; + bottom = stack_pointer[-3]; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache2 = top; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = bottom; SET_CURRENT_CACHED_VALUES(3); stack_pointer += -3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_LIST_APPEND_r13: { + case _SWAP_3_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef self; - _PyStackRef callable; - _PyStackRef none; - _PyStackRef c; - _PyStackRef s; + _PyStackRef top; + _PyStackRef bottom; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - arg = _stack_item_0; - self = stack_pointer[-1]; - callable = stack_pointer[-2]; - assert(oparg == 1); - PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); - if (!LOCK_OBJECT(self_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = arg; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); - int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); - UNLOCK_OBJECT(self_o); - if (err) { - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - c = callable; - s = self; - none = PyStackRef_None; - _tos_cache2 = s; - _tos_cache1 = c; - _tos_cache0 = none; + top = _stack_item_0; + bottom = stack_pointer[-2]; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache2 = top; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = bottom; SET_CURRENT_CACHED_VALUES(3); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_LIST_APPEND_r23: { + case _SWAP_3_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef self; - _PyStackRef callable; - _PyStackRef none; - _PyStackRef c; - _PyStackRef s; + _PyStackRef top; + _PyStackRef bottom; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - arg = _stack_item_1; - self = _stack_item_0; - callable = stack_pointer[-1]; - assert(oparg == 1); - PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); - if (!LOCK_OBJECT(self_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = arg; - _tos_cache0 = self; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); - int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); - UNLOCK_OBJECT(self_o); - if (err) { - stack_pointer[0] = self; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - c = callable; - s = self; - none = PyStackRef_None; - _tos_cache2 = s; - _tos_cache1 = c; - _tos_cache0 = none; + top = _stack_item_1; + bottom = stack_pointer[-1]; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache2 = top; + _tos_cache1 = _stack_item_0; + _tos_cache0 = bottom; SET_CURRENT_CACHED_VALUES(3); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_LIST_APPEND_r33: { + case _SWAP_3_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef self; - _PyStackRef callable; - _PyStackRef none; - _PyStackRef c; - _PyStackRef s; + _PyStackRef top; + _PyStackRef bottom; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - arg = _stack_item_2; - self = _stack_item_1; - callable = _stack_item_0; - assert(oparg == 1); - PyObject *self_o = PyStackRef_AsPyObjectBorrow(self); - if (!LOCK_OBJECT(self_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = arg; - _tos_cache1 = self; - _tos_cache0 = callable; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); - int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); - UNLOCK_OBJECT(self_o); - if (err) { - stack_pointer[0] = callable; - stack_pointer[1] = self; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - c = callable; - s = self; - none = PyStackRef_None; - _tos_cache2 = s; - _tos_cache1 = c; - _tos_cache0 = none; + top = _stack_item_2; + bottom = _stack_item_0; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache2 = top; + _tos_cache1 = _stack_item_1; + _tos_cache0 = bottom; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_METHOD_DESCRIPTOR_O_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SWAP_3_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef c; - _PyStackRef s; - _PyStackRef a; - oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; - } - PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o; - if (total_args != 2) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (!Py_IS_TYPE(method, &PyMethodDescr_Type)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyMethodDef *meth = method->d_method; - if (meth->ml_flags != METH_O) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (_Py_ReachedRecursionLimit(tstate)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - _PyStackRef arg_stackref = arguments[1]; - _PyStackRef self_stackref = arguments[0]; - if (!Py_IS_TYPE(PyStackRef_AsPyObjectBorrow(self_stackref), - method->d_common.d_type)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); - PyCFunction cfunc = meth->ml_meth; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, - PyStackRef_AsPyObjectBorrow(self_stackref), - PyStackRef_AsPyObjectBorrow(arg_stackref)); - stack_pointer = _PyFrame_GetStackPointer(frame); - _Py_LeaveRecursiveCallTstate(tstate); - assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - c = callable; - s = arguments[0]; - a = arguments[1]; - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache2 = a; - _tos_cache1 = s; - _tos_cache0 = c; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef top; + _PyStackRef bottom; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + top = _stack_item_3; + bottom = _stack_item_1; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache3 = top; + _tos_cache2 = _stack_item_2; + _tos_cache1 = bottom; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SWAP_3_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef top; + _PyStackRef bottom; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + top = _stack_item_4; + bottom = _stack_item_2; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache4 = top; + _tos_cache3 = _stack_item_3; + _tos_cache2 = bottom; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SWAP_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef res; + _PyStackRef top; + _PyStackRef bottom; + _PyStackRef _stack_item_0 = _tos_cache0; oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; - } - if (total_args == 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o; - if (!Py_IS_TYPE(method, &PyMethodDescr_Type)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyMethodDef *meth = method->d_method; - if (meth->ml_flags != (METH_FASTCALL|METH_KEYWORDS)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - PyTypeObject *d_type = method->d_common.d_type; - PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]); - assert(self != NULL); - if (!Py_IS_TYPE(self, d_type)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - STAT_INC(CALL, hit); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyCallMethodDescriptorFastWithKeywords_StackRefSteal( - callable, - meth, - self, - arguments, - total_args - ); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; + top = _stack_item_0; + bottom = stack_pointer[-1 - (oparg-2)]; + _PyStackRef temp = bottom; + bottom = top; + top = temp; + _tos_cache0 = top; SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + stack_pointer[-1 - (oparg-2)] = bottom; assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_METHOD_DESCRIPTOR_NOARGS_r01: { + /* _INSTRUMENTED_LINE is not a viable micro-op for tier 2 because it is instrumented */ + + /* _INSTRUMENTED_INSTRUCTION is not a viable micro-op for tier 2 because it is instrumented */ + + /* _INSTRUMENTED_JUMP_FORWARD is not a viable micro-op for tier 2 because it is instrumented */ + + /* _MONITOR_JUMP_BACKWARD is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ + + /* _INSTRUMENTED_NOT_TAKEN is not a viable micro-op for tier 2 because it is instrumented */ + + /* _INSTRUMENTED_POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 because it is instrumented */ + + /* _INSTRUMENTED_POP_JUMP_IF_FALSE is not a viable micro-op for tier 2 because it is instrumented */ + + /* _INSTRUMENTED_POP_JUMP_IF_NONE is not a viable micro-op for tier 2 because it is instrumented */ + + /* _INSTRUMENTED_POP_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 because it is instrumented */ + + case _GUARD_IS_TRUE_POP_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef res; - oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - assert(oparg == 0 || oparg == 1); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null)) { - args--; - total_args++; - } - if (total_args != 1) { + _PyStackRef flag; + flag = stack_pointer[-1]; + int is_true = PyStackRef_IsTrue(flag); + if (!is_true) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); JUMP_TO_JUMP_TARGET(); } - PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o; - if (!Py_IS_TYPE(method, &PyMethodDescr_Type)) { + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_TRUE_POP_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + flag = _stack_item_0; + int is_true = PyStackRef_IsTrue(flag); + if (!is_true) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - PyMethodDef *meth = method->d_method; - _PyStackRef self_stackref = args[0]; - PyObject *self = PyStackRef_AsPyObjectBorrow(self_stackref); - if (!Py_IS_TYPE(self, method->d_common.d_type)) { + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IS_TRUE_POP_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + flag = _stack_item_1; + int is_true = PyStackRef_IsTrue(flag); + if (!is_true) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - if (meth->ml_flags != METH_NOARGS) { + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IS_TRUE_POP_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + flag = _stack_item_2; + int is_true = PyStackRef_IsTrue(flag); + if (!is_true) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - if (_Py_ReachedRecursionLimit(tstate)) { + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IS_TRUE_POP_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + flag = _stack_item_3; + int is_true = PyStackRef_IsTrue(flag); + if (!is_true) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CALL, hit); - PyCFunction cfunc = meth->ml_meth; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); - _Py_LeaveRecursiveCallTstate(tstate); - assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(self_stackref); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IS_TRUE_POP_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + flag = _stack_item_4; + int is_true = PyStackRef_IsTrue(flag); + if (!is_true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_METHOD_DESCRIPTOR_FAST_r01: { + case _GUARD_IS_FALSE_POP_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef res; - oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; - } - if (total_args == 0) { + _PyStackRef flag; + flag = stack_pointer[-1]; + int is_false = PyStackRef_IsFalse(flag); + if (!is_false) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); JUMP_TO_JUMP_TARGET(); } - PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o; - if (!Py_IS_TYPE(method, &PyMethodDescr_Type)) { + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _GUARD_IS_FALSE_POP_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + flag = _stack_item_0; + int is_false = PyStackRef_IsFalse(flag); + if (!is_false) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - PyMethodDef *meth = method->d_method; - if (meth->ml_flags != METH_FASTCALL) { + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IS_FALSE_POP_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + flag = _stack_item_1; + int is_false = PyStackRef_IsFalse(flag); + if (!is_false) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]); - assert(self != NULL); - if (!Py_IS_TYPE(self, method->d_common.d_type)) { + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IS_FALSE_POP_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + flag = _stack_item_2; + int is_false = PyStackRef_IsFalse(flag); + if (!is_false) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CALL, hit); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyCallMethodDescriptorFast_StackRefSteal( - callable, - meth, - self, - arguments, - total_args - ); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _MONITOR_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ - - case _MAYBE_EXPAND_METHOD_KW_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_IS_FALSE_POP_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self_or_null; - _PyStackRef callable; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null = PyStackRef_FromPyObjectNew(self); - PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable; - callable = PyStackRef_FromPyObjectNew(method); - stack_pointer[-2 - oparg] = callable; - stack_pointer[-1 - oparg] = self_or_null; - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(temp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + flag = _stack_item_3; + int is_false = PyStackRef_IsFalse(flag); + if (!is_false) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer[-2 - oparg] = callable; - stack_pointer[-1 - oparg] = self_or_null; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _DO_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ - - case _PY_FRAME_KW_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_IS_FALSE_POP_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef kwnames; - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef new_frame; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - kwnames = _stack_item_0; - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + flag = _stack_item_4; + int is_false = PyStackRef_IsFalse(flag); + if (!is_false) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); - int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); - assert(Py_TYPE(callable_o) == &PyFunction_Type); - int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags; - PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); - stack_pointer[0] = kwnames; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, callable, locals, - arguments, positional_args, kwnames_o, frame - ); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(kwnames); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (temp == NULL) { + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BIT_IS_SET_POP_4_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = stack_pointer[-1]; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); } - new_frame = PyStackRef_Wrap(temp); - _tos_cache0 = new_frame; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _CHECK_FUNCTION_VERSION_KW_r11: { + case _GUARD_BIT_IS_SET_POP_4_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - callable = stack_pointer[-2 - oparg]; - uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (!PyFunction_Check(callable_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - PyFunctionObject *func = (PyFunctionObject *)callable_o; - if (func->func_version != func_version) { + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_0; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_METHOD_VERSION_KW_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_SET_POP_4_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - _PyStackRef callable; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - uint32_t func_version = (uint32_t)CURRENT_OPERAND0_32(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (Py_TYPE(callable_o) != &PyMethod_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - PyObject *func = ((PyMethodObject *)callable_o)->im_func; - if (!PyFunction_Check(func)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (((PyFunctionObject *)func)->func_version != func_version) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (!PyStackRef_IsNull(null)) { + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_1; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); @@ -16113,264 +30290,261 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _EXPAND_METHOD_KW_r11: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - assert(PyStackRef_IsNull(self_or_null)); - _PyStackRef callable_s = callable; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - assert(Py_TYPE(callable_o) == &PyMethod_Type); - self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(callable)); - stack_pointer[-2 - oparg] = callable; - stack_pointer[-1 - oparg] = self_or_null; - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable_s); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = _stack_item_0; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _CHECK_IS_NOT_PY_CALLABLE_KW_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_SET_POP_4_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callable; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (PyFunction_Check(callable_o)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (Py_TYPE(callable_o) == &PyMethod_Type) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_2; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_KW_NON_PY_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_SET_POP_4_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef kwnames; - _PyStackRef *args; - _PyStackRef self_or_null; - _PyStackRef callable; - _PyStackRef res; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - kwnames = _stack_item_0; - args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - #if TIER_ONE - assert(opcode != INSTRUMENTED_CALL); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; #endif - int total_args = oparg; - _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null)) { - arguments--; - total_args++; - } - stack_pointer[0] = kwnames; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _Py_VectorCall_StackRefSteal( - callable, - arguments, - total_args, - kwnames); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - stack_pointer += -3 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -3 - oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MAKE_CALLARGS_A_TUPLE_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_BIT_IS_SET_POP_4_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef callargs; - _PyStackRef func; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - callargs = _stack_item_1; - func = stack_pointer[-1]; - PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs); - if (!PyTuple_CheckExact(callargs_o)) { - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = callargs; - stack_pointer[2] = _stack_item_2; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *tuple_o = PySequence_Tuple(callargs_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (tuple_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - _PyStackRef temp = callargs; - callargs = PyStackRef_FromPyObjectSteal(tuple_o); - stack_pointer[-2] = callargs; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(temp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -3; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; - _tos_cache1 = callargs; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ - - case _CHECK_IS_PY_CALLABLE_EX_r03: { + case _GUARD_BIT_IS_SET_POP_5_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_st; - func_st = stack_pointer[-4]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - if (Py_TYPE(func) != &PyFunction_Type) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + _PyStackRef flag; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = stack_pointer[-1]; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = stack_pointer[-1]; - _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = stack_pointer[-3]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _CHECK_IS_PY_CALLABLE_EX_r13: { + case _GUARD_BIT_IS_SET_POP_5_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_st; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - func_st = stack_pointer[-3]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - if (Py_TYPE(func) != &PyFunction_Type) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_0; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_0; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = stack_pointer[-2]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_IS_PY_CALLABLE_EX_r23: { + case _GUARD_BIT_IS_SET_POP_5_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_st; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - func_st = stack_pointer[-2]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - if (Py_TYPE(func) != &PyFunction_Type) { + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_1; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BIT_IS_SET_POP_5_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_2; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_1; - _tos_cache1 = _stack_item_0; - _tos_cache0 = stack_pointer[-1]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_IS_PY_CALLABLE_EX_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_BIT_IS_SET_POP_5_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_st; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - func_st = stack_pointer[-1]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - if (Py_TYPE(func) != &PyFunction_Type) { + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; @@ -16378,147 +30552,196 @@ SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - if (((PyFunctionObject *)func)->vectorcall != _PyFunction_Vectorcall) { + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BIT_IS_SET_POP_5_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _PY_FRAME_EX_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_BIT_IS_SET_POP_6_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef kwargs_st; - _PyStackRef callargs_st; - _PyStackRef func_st; - _PyStackRef ex_frame; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - kwargs_st = _stack_item_2; - callargs_st = _stack_item_1; - func_st = stack_pointer[-1]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - PyObject *callargs = PyStackRef_AsPyObjectSteal(callargs_st); - assert(PyTuple_CheckExact(callargs)); - assert(Py_TYPE(func) == &PyFunction_Type); - assert(((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall); - PyObject *kwargs = PyStackRef_IsNull(kwargs_st) ? NULL : PyStackRef_AsPyObjectSteal(kwargs_st); - assert(kwargs == NULL || PyDict_CheckExact(kwargs)); - Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); - int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; - PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex( - tstate, func_st, locals, - nargs, callargs, kwargs, frame); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (new_frame == NULL) { + _PyStackRef flag; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = stack_pointer[-1]; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); } - ex_frame = PyStackRef_Wrap(new_frame); - _tos_cache0 = ex_frame; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _CHECK_IS_NOT_PY_CALLABLE_EX_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_BIT_IS_SET_POP_6_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_st; - func_st = stack_pointer[-4]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_0; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = stack_pointer[-1]; - _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = stack_pointer[-3]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_IS_NOT_PY_CALLABLE_EX_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_SET_POP_6_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_st; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - func_st = stack_pointer[-3]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_1; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_0; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = stack_pointer[-2]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_IS_NOT_PY_CALLABLE_EX_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_BIT_IS_SET_POP_6_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_st; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - func_st = stack_pointer[-2]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_2; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); JUMP_TO_JUMP_TARGET(); } - _tos_cache2 = _stack_item_1; - _tos_cache1 = _stack_item_0; - _tos_cache0 = stack_pointer[-1]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_IS_NOT_PY_CALLABLE_EX_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_BIT_IS_SET_POP_6_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_st; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - func_st = stack_pointer[-1]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - if (Py_TYPE(func) == &PyFunction_Type && ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { UOP_STAT_INC(uopcode, miss); _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; @@ -16532,824 +30755,1044 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CALL_FUNCTION_EX_NON_PY_GENERAL_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_BIT_IS_SET_POP_6_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef kwargs_st; - _PyStackRef callargs_st; - _PyStackRef null; - _PyStackRef func_st; - _PyStackRef result; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - kwargs_st = _stack_item_2; - callargs_st = _stack_item_1; - null = _stack_item_0; - func_st = stack_pointer[-1]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); - (void)null; - assert(PyTuple_CheckExact(callargs)); - PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st); - assert(kwargs == NULL || PyDict_CheckExact(kwargs)); - stack_pointer[0] = null; - stack_pointer[1] = callargs_st; - stack_pointer[2] = kwargs_st; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *result_o = PyObject_Call(func, callargs, kwargs); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_XCLOSE(kwargs_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callargs_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(func_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (result_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - result = PyStackRef_FromPyObjectSteal(result_o); - _tos_cache0 = result; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MAKE_FUNCTION_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_SET_POP_7_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef codeobj_st; - _PyStackRef func; - _PyStackRef _stack_item_0 = _tos_cache0; - codeobj_st = _stack_item_0; - PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); - stack_pointer[0] = codeobj_st; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyFunctionObject *func_obj = (PyFunctionObject *) - PyFunction_New(codeobj, GLOBALS()); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(codeobj_st); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (func_obj == NULL) { + _PyStackRef flag; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + flag = stack_pointer[-1]; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); } - _PyFunction_SetVersion( - func_obj, ((PyCodeObject *)codeobj)->co_version); - func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); - _tos_cache0 = func; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _SET_FUNCTION_ATTRIBUTE_r01: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_in; - _PyStackRef attr_st; - _PyStackRef func_out; - oparg = CURRENT_OPARG(); - func_in = stack_pointer[-1]; - attr_st = stack_pointer[-2]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); - PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); - func_out = func_in; - assert(PyFunction_Check(func)); - size_t offset = _Py_FunctionAttributeOffsets[oparg]; - assert(offset != 0); - PyObject **ptr = (PyObject **)(((char *)func) + offset); - assert(*ptr == NULL); - *ptr = attr; - _tos_cache0 = func_out; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -2; + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _SET_FUNCTION_ATTRIBUTE_r11: { + case _GUARD_BIT_IS_SET_POP_7_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_in; - _PyStackRef attr_st; - _PyStackRef func_out; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - func_in = _stack_item_0; - attr_st = stack_pointer[-1]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); - PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); - func_out = func_in; - assert(PyFunction_Check(func)); - size_t offset = _Py_FunctionAttributeOffsets[oparg]; - assert(offset != 0); - PyObject **ptr = (PyObject **)(((char *)func) + offset); - assert(*ptr == NULL); - *ptr = attr; - _tos_cache0 = func_out; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = 7; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_0; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SET_FUNCTION_ATTRIBUTE_r21: { + case _GUARD_BIT_IS_SET_POP_7_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_in; - _PyStackRef attr_st; - _PyStackRef func_out; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - func_in = _stack_item_1; - attr_st = _stack_item_0; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); - PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); - func_out = func_in; - assert(PyFunction_Check(func)); - size_t offset = _Py_FunctionAttributeOffsets[oparg]; - assert(offset != 0); - PyObject **ptr = (PyObject **)(((char *)func) + offset); - assert(*ptr == NULL); - *ptr = attr; - _tos_cache0 = func_out; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_1; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SET_FUNCTION_ATTRIBUTE_r32: { + case _GUARD_BIT_IS_SET_POP_7_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef func_in; - _PyStackRef attr_st; - _PyStackRef func_out; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - func_in = _stack_item_2; - attr_st = _stack_item_1; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); - PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); - func_out = func_in; - assert(PyFunction_Check(func)); - size_t offset = _Py_FunctionAttributeOffsets[oparg]; - assert(offset != 0); - PyObject **ptr = (PyObject **)(((char *)func) + offset); - assert(*ptr == NULL); - *ptr = attr; - _tos_cache1 = func_out; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_2; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _RETURN_GENERATOR_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_BIT_IS_SET_POP_7_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef res; - assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (gen == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); } - assert(STACK_LEVEL() <= 2); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++; - _PyFrame_Copy(frame, gen_frame); - assert(frame->frame_obj == NULL); - gen->gi_frame_state = FRAME_CREATED; - gen_frame->owner = FRAME_OWNED_BY_GENERATOR; - _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous; - _PyThreadState_PopFrame(tstate, frame); - frame = tstate->current_frame = prev; - LOAD_IP(frame->return_offset); - stack_pointer = _PyFrame_GetStackPointer(frame); - res = PyStackRef_FromPyObjectStealMortal((PyObject *)gen); - LLTRACE_RESUME_FRAME(); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _BUILD_SLICE_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_BIT_IS_SET_POP_7_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef *args; - _PyStackRef slice; - oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - PyObject *start_o = PyStackRef_AsPyObjectBorrow(args[0]); - PyObject *stop_o = PyStackRef_AsPyObjectBorrow(args[1]); - PyObject *step_o = oparg == 3 ? PyStackRef_AsPyObjectBorrow(args[2]) : NULL; - PyObject *slice_o = PySlice_New(start_o, stop_o, step_o); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyStackRef tmp; - for (int _i = oparg; --_i >= 0;) { - tmp = args[_i]; - args[_i] = PyStackRef_NULL; - PyStackRef_CLOSE(tmp); - } - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -oparg; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (slice_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); } - slice = PyStackRef_FromPyObjectStealMortal(slice_o); - _tos_cache0 = slice; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CONVERT_VALUE_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_SET_POP_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - _PyStackRef result; - _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef flag; oparg = CURRENT_OPARG(); - value = _stack_item_0; - conversion_func conv_fn; - assert(oparg >= FVC_STR && oparg <= FVC_ASCII); - conv_fn = _PyEval_ConversionFuncs[oparg]; - stack_pointer[0] = value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(value); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (result_o == NULL) { + flag = stack_pointer[-1]; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); } - result = PyStackRef_FromPyObjectSteal(result_o); - _tos_cache0 = result; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _FORMAT_SIMPLE_r11: { + case _GUARD_BIT_IS_SET_POP_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; - _PyStackRef res; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - value = _stack_item_0; - PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); - if (!PyUnicode_CheckExact(value_o)) { - stack_pointer[0] = value; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = PyObject_Format(value_o, NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(value); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); - } - res = PyStackRef_FromPyObjectSteal(res_o); - } - else { - res = value; + oparg = CURRENT_OPARG(); + flag = _stack_item_0; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); } - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _FORMAT_WITH_SPEC_r21: { + case _GUARD_BIT_IS_SET_POP_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef fmt_spec; - _PyStackRef value; - _PyStackRef res; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - fmt_spec = _stack_item_1; - value = _stack_item_0; - stack_pointer[0] = value; - stack_pointer[1] = fmt_spec; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); - _PyStackRef tmp = fmt_spec; - fmt_spec = PyStackRef_NULL; - stack_pointer[-1] = fmt_spec; - PyStackRef_CLOSE(tmp); - tmp = value; - value = PyStackRef_NULL; - stack_pointer[-2] = value; - PyStackRef_CLOSE(tmp); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - if (res_o == NULL) { - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + oparg = CURRENT_OPARG(); + flag = _stack_item_1; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); } - res = PyStackRef_FromPyObjectSteal(res_o); - _tos_cache0 = res; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_1_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_BIT_IS_SET_POP_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; - bottom = stack_pointer[-1]; - top = PyStackRef_DUP(bottom); - _tos_cache1 = top; - _tos_cache0 = bottom; + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); + flag = _stack_item_2; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_1_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_SET_POP_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - bottom = _stack_item_0; - top = PyStackRef_DUP(bottom); - _tos_cache1 = top; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_1_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_BIT_IS_SET_POP_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - bottom = _stack_item_1; - top = PyStackRef_DUP(bottom); - _tos_cache2 = top; - _tos_cache1 = bottom; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = CURRENT_OPARG(); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_2_r03: { + case _GUARD_BIT_IS_UNSET_POP_4_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; - bottom = stack_pointer[-2]; - top = PyStackRef_DUP(bottom); - _tos_cache2 = top; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + _PyStackRef flag; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = stack_pointer[-1]; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _COPY_2_r13: { + case _GUARD_BIT_IS_UNSET_POP_4_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - bottom = stack_pointer[-1]; - top = PyStackRef_DUP(bottom); - _tos_cache2 = top; - _tos_cache1 = _stack_item_0; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_0; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_2_r23: { + case _GUARD_BIT_IS_UNSET_POP_4_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - bottom = _stack_item_0; - top = PyStackRef_DUP(bottom); - _tos_cache2 = top; - _tos_cache1 = _stack_item_1; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _COPY_3_r03: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; - bottom = stack_pointer[-3]; - top = PyStackRef_DUP(bottom); - _tos_cache2 = top; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = stack_pointer[-2]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_1; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_3_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_UNSET_POP_4_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - bottom = stack_pointer[-2]; - top = PyStackRef_DUP(bottom); - _tos_cache2 = top; - _tos_cache1 = _stack_item_0; - _tos_cache0 = stack_pointer[-1]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_2; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_3_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_BIT_IS_UNSET_POP_4_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - bottom = stack_pointer[-1]; - top = PyStackRef_DUP(bottom); - _tos_cache2 = top; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_3_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_BIT_IS_UNSET_POP_4_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - bottom = _stack_item_0; - top = PyStackRef_DUP(bottom); - _tos_cache2 = top; - _tos_cache1 = _stack_item_2; - _tos_cache0 = _stack_item_1; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer[0] = bottom; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 4; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _COPY_r01: { + case _GUARD_BIT_IS_UNSET_POP_5_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef bottom; - _PyStackRef top; - oparg = CURRENT_OPARG(); - bottom = stack_pointer[-1 - (oparg-1)]; - top = PyStackRef_DUP(bottom); - _tos_cache0 = top; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef flag; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = stack_pointer[-1]; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _BINARY_OP_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_BIT_IS_UNSET_POP_5_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef rhs; - _PyStackRef lhs; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - rhs = _stack_item_1; - lhs = _stack_item_0; - PyObject *lhs_o = PyStackRef_AsPyObjectBorrow(lhs); - PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs); - assert(_PyEval_BinaryOps[oparg]); - stack_pointer[0] = lhs; - stack_pointer[1] = rhs; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) { + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_0; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_ERROR(); + JUMP_TO_JUMP_TARGET(); } - res = PyStackRef_FromPyObjectSteal(res_o); - l = lhs; - r = rhs; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_2_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_BIT_IS_UNSET_POP_5_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; - top = stack_pointer[-1]; - bottom = stack_pointer[-2]; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache1 = top; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_1; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_2_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_UNSET_POP_5_r32: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - top = _stack_item_0; - bottom = stack_pointer[-1]; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache1 = top; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_2; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_2_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_BIT_IS_UNSET_POP_5_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - top = _stack_item_1; - bottom = _stack_item_0; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache1 = top; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_2_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_BIT_IS_UNSET_POP_5_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - top = _stack_item_2; - bottom = _stack_item_1; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache2 = top; - _tos_cache1 = bottom; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 5; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_3_r03: { + case _GUARD_BIT_IS_UNSET_POP_6_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; - top = stack_pointer[-1]; - bottom = stack_pointer[-3]; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache2 = top; - _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; + _PyStackRef flag; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = stack_pointer[-1]; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + SET_CURRENT_CACHED_VALUES(0); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _SWAP_3_r13: { + case _GUARD_BIT_IS_UNSET_POP_6_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - top = _stack_item_0; - bottom = stack_pointer[-2]; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache2 = top; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_0; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_3_r23: { + case _GUARD_BIT_IS_UNSET_POP_6_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - top = _stack_item_1; - bottom = stack_pointer[-1]; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache2 = top; - _tos_cache1 = _stack_item_0; - _tos_cache0 = bottom; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_1; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_3_r33: { + case _GUARD_BIT_IS_UNSET_POP_6_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - top = _stack_item_2; - bottom = _stack_item_0; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache2 = top; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_2; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } _tos_cache1 = _stack_item_1; - _tos_cache0 = bottom; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BIT_IS_UNSET_POP_6_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SWAP_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_BIT_IS_UNSET_POP_6_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef top; - _PyStackRef bottom; + _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - top = _stack_item_0; - bottom = stack_pointer[-1 - (oparg-2)]; - _PyStackRef temp = bottom; - bottom = top; - top = temp; - _tos_cache0 = top; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer[-1 - (oparg-2)] = bottom; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 6; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - /* _INSTRUMENTED_LINE is not a viable micro-op for tier 2 because it is instrumented */ - - /* _INSTRUMENTED_INSTRUCTION is not a viable micro-op for tier 2 because it is instrumented */ - - /* _INSTRUMENTED_JUMP_FORWARD is not a viable micro-op for tier 2 because it is instrumented */ - - /* _MONITOR_JUMP_BACKWARD is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ - - /* _INSTRUMENTED_NOT_TAKEN is not a viable micro-op for tier 2 because it is instrumented */ - - /* _INSTRUMENTED_POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 because it is instrumented */ - - /* _INSTRUMENTED_POP_JUMP_IF_FALSE is not a viable micro-op for tier 2 because it is instrumented */ - - /* _INSTRUMENTED_POP_JUMP_IF_NONE is not a viable micro-op for tier 2 because it is instrumented */ - - /* _INSTRUMENTED_POP_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 because it is instrumented */ - - case _GUARD_IS_TRUE_POP_r00: { + case _GUARD_BIT_IS_UNSET_POP_7_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef flag; + oparg = 7; + assert(oparg == CURRENT_OPARG()); flag = stack_pointer[-1]; - int is_true = PyStackRef_IsTrue(flag); - if (!is_true) { + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); stack_pointer += -1; @@ -17363,14 +31806,22 @@ break; } - case _GUARD_IS_TRUE_POP_r10: { + case _GUARD_BIT_IS_UNSET_POP_7_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; + oparg = 7; + assert(oparg == CURRENT_OPARG()); flag = _stack_item_0; - int is_true = PyStackRef_IsTrue(flag); - if (!is_true) { + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); @@ -17378,17 +31829,28 @@ SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_TRUE_POP_r21: { + case _GUARD_BIT_IS_UNSET_POP_7_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + oparg = 7; + assert(oparg == CURRENT_OPARG()); flag = _stack_item_1; - int is_true = PyStackRef_IsTrue(flag); - if (!is_true) { + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); @@ -17398,18 +31860,29 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_TRUE_POP_r32: { + case _GUARD_BIT_IS_UNSET_POP_7_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + oparg = 7; + assert(oparg == CURRENT_OPARG()); flag = _stack_item_2; - int is_true = PyStackRef_IsTrue(flag); - if (!is_true) { + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; @@ -17421,15 +31894,101 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_FALSE_POP_r00: { + case _GUARD_BIT_IS_UNSET_POP_7_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BIT_IS_UNSET_POP_7_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = 7; + assert(oparg == CURRENT_OPARG()); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BIT_IS_UNSET_POP_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef flag; + oparg = CURRENT_OPARG(); flag = stack_pointer[-1]; - int is_false = PyStackRef_IsFalse(flag); - if (!is_false) { + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); stack_pointer += -1; @@ -17443,14 +32002,21 @@ break; } - case _GUARD_IS_FALSE_POP_r10: { + case _GUARD_BIT_IS_UNSET_POP_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; + oparg = CURRENT_OPARG(); flag = _stack_item_0; - int is_false = PyStackRef_IsFalse(flag); - if (!is_false) { + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); @@ -17458,17 +32024,27 @@ SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_FALSE_POP_r21: { + case _GUARD_BIT_IS_UNSET_POP_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + oparg = CURRENT_OPARG(); flag = _stack_item_1; - int is_false = PyStackRef_IsFalse(flag); - if (!is_false) { + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); @@ -17478,50 +32054,136 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_FALSE_POP_r32: { + case _GUARD_BIT_IS_UNSET_POP_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + oparg = CURRENT_OPARG(); flag = _stack_item_2; - int is_false = PyStackRef_IsFalse(flag); - if (!is_false) { + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BIT_IS_UNSET_POP_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + flag = _stack_item_3; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_BIT_IS_UNSET_POP_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef flag; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = CURRENT_OPARG(); + flag = _stack_item_4; + #ifdef Py_STACKREF_DEBUG + uintptr_t bits = flag.index; + #else + uintptr_t bits = flag.bits; + #endif + uintptr_t set = (1 << oparg) & bits; + if (set != 0) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_4_r00: { + case _GUARD_IS_NONE_POP_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef val; + val = stack_pointer[-1]; + int is_none = PyStackRef_IsNone(val); + if (!is_none) { stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(val); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (1) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } } SET_CURRENT_CACHED_VALUES(0); stack_pointer += -1; @@ -17530,237 +32192,356 @@ break; } - case _GUARD_BIT_IS_SET_POP_4_r10: { + case _GUARD_IS_NONE_POP_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; + _PyStackRef val; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + val = _stack_item_0; + int is_none = PyStackRef_IsNone(val); + if (!is_none) { + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(val); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (1) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } } SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_4_r21: { + case _GUARD_IS_NONE_POP_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; + _PyStackRef val; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); + val = _stack_item_1; + int is_none = PyStackRef_IsNone(val); + if (!is_none) { + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(val); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (1) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } } _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_4_r32: { + case _GUARD_IS_NONE_POP_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; + _PyStackRef val; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + val = _stack_item_2; + int is_none = PyStackRef_IsNone(val); + if (!is_none) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(val); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (1) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); + } + + case _GUARD_IS_NONE_POP_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + val = _stack_item_3; + int is_none = PyStackRef_IsNone(val); + if (!is_none) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(val); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (1) { + UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } } + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_5_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _GUARD_IS_NONE_POP_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + val = _stack_item_4; + int is_none = PyStackRef_IsNone(val); + if (!is_none) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(val); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (1) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { + } + + case _GUARD_IS_NOT_NONE_POP_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef val; + _PyStackRef _stack_item_0 = _tos_cache0; + val = _stack_item_0; + int is_none = PyStackRef_IsNone(val); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(val); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (is_none) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); JUMP_TO_JUMP_TARGET(); } + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _JUMP_TO_TOP_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + JUMP_TO_JUMP_TARGET(); + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _SET_IP_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _GUARD_BIT_IS_SET_POP_5_r10: { + case _SET_IP_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - SET_CURRENT_CACHED_VALUES(0); + PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_5_r21: { + case _SET_IP_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_5_r32: { + case _SET_IP_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_6_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SET_IP_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); - } - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_6_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SET_IP_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { + } + + case _CHECK_STACK_SPACE_OPERAND_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); + assert(framesize <= INT_MAX); + if (!_PyThreadState_HasStackSpace(tstate, framesize)) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); @@ -17770,22 +32551,14 @@ break; } - case _GUARD_BIT_IS_SET_POP_6_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_STACK_SPACE_OPERAND_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { + uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); + assert(framesize <= INT_MAX); + if (!_PyThreadState_HasStackSpace(tstate, framesize)) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); @@ -17795,25 +32568,20 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_6_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_STACK_SPACE_OPERAND_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { + uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); + assert(framesize <= INT_MAX); + if (!_PyThreadState_HasStackSpace(tstate, framesize)) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; @@ -17825,586 +32593,722 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; - } - - case _GUARD_BIT_IS_SET_POP_7_r00: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); - } - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; } - case _GUARD_BIT_IS_SET_POP_7_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CHECK_STACK_SPACE_OPERAND_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); + assert(framesize <= INT_MAX); + if (!_PyThreadState_HasStackSpace(tstate, framesize)) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_7_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_STACK_SPACE_OPERAND_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); + assert(framesize <= INT_MAX); + if (!_PyThreadState_HasStackSpace(tstate, framesize)) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_7_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_STACK_SPACE_OPERAND_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); + assert(framesize <= INT_MAX); + if (!_PyThreadState_HasStackSpace(tstate, framesize)) { UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_r00: { + case _SAVE_RETURN_OFFSET_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; oparg = CURRENT_OPARG(); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; + #if TIER_ONE + frame->return_offset = (uint16_t)(next_instr - this_instr); + #endif + #if TIER_TWO + frame->return_offset = oparg; #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); - } SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _GUARD_BIT_IS_SET_POP_r10: { + case _SAVE_RETURN_OFFSET_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; oparg = CURRENT_OPARG(); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; + #if TIER_ONE + frame->return_offset = (uint16_t)(next_instr - this_instr); #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - SET_CURRENT_CACHED_VALUES(0); + #if TIER_TWO + frame->return_offset = oparg; + #endif + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_r21: { + case _SAVE_RETURN_OFFSET_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; oparg = CURRENT_OPARG(); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; + #if TIER_ONE + frame->return_offset = (uint16_t)(next_instr - this_instr); #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + #if TIER_TWO + frame->return_offset = oparg; + #endif + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_SET_POP_r32: { + case _SAVE_RETURN_OFFSET_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; oparg = CURRENT_OPARG(); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; + #if TIER_ONE + frame->return_offset = (uint16_t)(next_instr - this_instr); #endif - uintptr_t set = (1 << oparg) & bits; - if (set == 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + #if TIER_TWO + frame->return_offset = oparg; + #endif + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _GUARD_BIT_IS_UNSET_POP_4_r00: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); - } - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; - } - - case _GUARD_BIT_IS_UNSET_POP_4_r10: { - CHECK_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - SET_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; } - case _GUARD_BIT_IS_UNSET_POP_4_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SAVE_RETURN_OFFSET_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + oparg = CURRENT_OPARG(); + #if TIER_ONE + frame->return_offset = (uint16_t)(next_instr - this_instr); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + #if TIER_TWO + frame->return_offset = oparg; + #endif + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_4_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SAVE_RETURN_OFFSET_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 4; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + oparg = CURRENT_OPARG(); + #if TIER_ONE + frame->return_offset = (uint16_t)(next_instr - this_instr); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + #if TIER_TWO + frame->return_offset = oparg; + #endif + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _EXIT_TRACE_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + _PyExitData *exit = (_PyExitData *)exit_p; + #if defined(Py_DEBUG) && !defined(_Py_JIT) + const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) + + exit->target; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("SIDE EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code], exit->is_control_flow); + stack_pointer = _PyFrame_GetStackPointer(frame); + } + #endif + tstate->jit_exit = exit; + SET_CURRENT_CACHED_VALUES(0); + TIER2_TO_TIER2(exit->executor); } - case _GUARD_BIT_IS_UNSET_POP_5_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _EXIT_TRACE_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; + _PyStackRef _stack_item_0 = _tos_cache0; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + _PyExitData *exit = (_PyExitData *)exit_p; + #if defined(Py_DEBUG) && !defined(_Py_JIT) + const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) + + exit->target; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("SIDE EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code], exit->is_control_flow); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; } + #endif + tstate->jit_exit = exit; SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + TIER2_TO_TIER2(exit->executor); + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_5_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _EXIT_TRACE_r20: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + _PyStackRef _stack_item_1 = _tos_cache1; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + _PyExitData *exit = (_PyExitData *)exit_p; + #if defined(Py_DEBUG) && !defined(_Py_JIT) + const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) + + exit->target; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("SIDE EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code], exit->is_control_flow); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; } + #endif + tstate->jit_exit = exit; SET_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + TIER2_TO_TIER2(exit->executor); + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_5_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _EXIT_TRACE_r30: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + _PyStackRef _stack_item_2 = _tos_cache2; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + _PyExitData *exit = (_PyExitData *)exit_p; + #if defined(Py_DEBUG) && !defined(_Py_JIT) + const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) + + exit->target; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("SIDE EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code], exit->is_control_flow); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -3; + } + #endif + tstate->jit_exit = exit; + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + TIER2_TO_TIER2(exit->executor); #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; } - case _GUARD_BIT_IS_UNSET_POP_5_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _EXIT_TRACE_r40: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 5; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + _PyExitData *exit = (_PyExitData *)exit_p; + #if defined(Py_DEBUG) && !defined(_Py_JIT) + const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) + + exit->target; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("SIDE EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code], exit->is_control_flow); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -4; + } + #endif + tstate->jit_exit = exit; + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + TIER2_TO_TIER2(exit->executor); #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; } - case _GUARD_BIT_IS_UNSET_POP_6_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _EXIT_TRACE_r50: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + _PyExitData *exit = (_PyExitData *)exit_p; + #if defined(Py_DEBUG) && !defined(_Py_JIT) + const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) + + exit->target; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer[4] = _stack_item_4; + stack_pointer += 5; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("SIDE EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code], exit->is_control_flow); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -5; + } + #endif + tstate->jit_exit = exit; + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer[4] = _stack_item_4; + stack_pointer += 5; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + TIER2_TO_TIER2(exit->executor); #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); + } + + case _DYNAMIC_EXIT_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + #if defined(Py_DEBUG) && !defined(_Py_JIT) + _PyExitData *exit = (_PyExitData *)exit_p; + _Py_CODEUNIT *target = frame->instr_ptr; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("DYNAMIC EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code]); + stack_pointer = _PyFrame_GetStackPointer(frame); } + #endif SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + GOTO_TIER_ONE(frame->instr_ptr); } - case _GUARD_BIT_IS_UNSET_POP_6_r10: { + case _DYNAMIC_EXIT_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + #if defined(Py_DEBUG) && !defined(_Py_JIT) + _PyExitData *exit = (_PyExitData *)exit_p; + _Py_CODEUNIT *target = frame->instr_ptr; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("DYNAMIC EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code]); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; } + #endif SET_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + GOTO_TIER_ONE(frame->instr_ptr); + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_6_r21: { + case _DYNAMIC_EXIT_r20: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + #if defined(Py_DEBUG) && !defined(_Py_JIT) + _PyExitData *exit = (_PyExitData *)exit_p; + _Py_CODEUNIT *target = frame->instr_ptr; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("DYNAMIC EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code]); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + } + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + GOTO_TIER_ONE(frame->instr_ptr); #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; } - case _GUARD_BIT_IS_UNSET_POP_6_r32: { + case _DYNAMIC_EXIT_r30: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 6; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + #if defined(Py_DEBUG) && !defined(_Py_JIT) + _PyExitData *exit = (_PyExitData *)exit_p; + _Py_CODEUNIT *target = frame->instr_ptr; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("DYNAMIC EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code]); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -3; + } + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + GOTO_TIER_ONE(frame->instr_ptr); #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; } - case _GUARD_BIT_IS_UNSET_POP_7_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _DYNAMIC_EXIT_r40: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + #if defined(Py_DEBUG) && !defined(_Py_JIT) + _PyExitData *exit = (_PyExitData *)exit_p; + _Py_CODEUNIT *target = frame->instr_ptr; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("DYNAMIC EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code]); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -4; } + #endif SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + GOTO_TIER_ONE(frame->instr_ptr); + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_7_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _DYNAMIC_EXIT_r50: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); + #if defined(Py_DEBUG) && !defined(_Py_JIT) + _PyExitData *exit = (_PyExitData *)exit_p; + _Py_CODEUNIT *target = frame->instr_ptr; + OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); + if (frame->lltrace >= 3) { + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer[4] = _stack_item_4; + stack_pointer += 5; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + printf("DYNAMIC EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %tu, temp %d, target %d -> %s]\n", + exit - current_executor->exits, exit->temperature.value_and_backoff, + (int)(target - _PyFrame_GetBytecode(frame)), + _PyOpcode_OpName[target->op.code]); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -5; + } + #endif + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer[4] = _stack_item_4; + stack_pointer += 5; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + GOTO_TIER_ONE(frame->instr_ptr); #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { + } + + case _CHECK_VALIDITY_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + if (!current_executor->vm_data.valid) { UOP_STAT_INC(uopcode, miss); SET_CURRENT_CACHED_VALUES(0); JUMP_TO_JUMP_TARGET(); @@ -18414,22 +33318,12 @@ break; } - case _GUARD_BIT_IS_UNSET_POP_7_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_VALIDITY_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { + if (!current_executor->vm_data.valid) { UOP_STAT_INC(uopcode, miss); _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(1); @@ -18439,25 +33333,18 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_7_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _CHECK_VALIDITY_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - oparg = 7; - assert(oparg == CURRENT_OPARG()); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { + if (!current_executor->vm_data.valid) { UOP_STAT_INC(uopcode, miss); _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; @@ -18469,1992 +33356,2695 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _CHECK_VALIDITY_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; - oparg = CURRENT_OPARG(); - flag = stack_pointer[-1]; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + if (!current_executor->vm_data.valid) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _CHECK_VALIDITY_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - flag = _stack_item_0; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + if (!current_executor->vm_data.valid) { UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _CHECK_VALIDITY_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - flag = _stack_item_1; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; - #else - uintptr_t bits = flag.bits; - #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + if (!current_executor->vm_data.valid) { UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_CONST_INLINE_r01: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_BIT_IS_UNSET_POP_r32: { + case _LOAD_CONST_INLINE_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_CONST_INLINE_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_CONST_INLINE_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef flag; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - flag = _stack_item_2; - #ifdef Py_STACKREF_DEBUG - uintptr_t bits = flag.index; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; #else - uintptr_t bits = flag.bits; + Py_UNREACHABLE(); #endif - uintptr_t set = (1 << oparg) & bits; - if (set != 0) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + } + + case _LOAD_CONST_INLINE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_NONE_POP_r00: { + case _POP_TOP_LOAD_CONST_INLINE_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef pop; + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + pop = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop); + stack_pointer = _PyFrame_GetStackPointer(frame); + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_CONST_INLINE_BORROW_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef val; - val = stack_pointer[-1]; - int is_none = PyStackRef_IsNone(val); - if (!is_none) { - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(val); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (1) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - } - SET_CURRENT_CACHED_VALUES(0); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef value; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_NONE_POP_r10: { + case _LOAD_CONST_INLINE_BORROW_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef val; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - val = _stack_item_0; - int is_none = PyStackRef_IsNone(val); - if (!is_none) { - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(val); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (1) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - } - SET_CURRENT_CACHED_VALUES(0); + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_NONE_POP_r21: { + case _LOAD_CONST_INLINE_BORROW_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef val; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - val = _stack_item_1; - int is_none = PyStackRef_IsNone(val); - if (!is_none) { - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(val); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (1) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); - } - } + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_NONE_POP_r32: { + case _LOAD_CONST_INLINE_BORROW_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef val; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - val = _stack_item_2; - int is_none = PyStackRef_IsNone(val); - if (!is_none) { - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(val); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (1) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - JUMP_TO_JUMP_TARGET(); - } - } + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_IS_NOT_NONE_POP_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _LOAD_CONST_INLINE_BORROW_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef val; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - val = _stack_item_0; - int is_none = PyStackRef_IsNone(val); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache4 = value; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _POP_CALL_r20: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null; + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + null = _stack_item_1; + callable = _stack_item_0; + (void)null; _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(val); + PyStackRef_CLOSE(callable); stack_pointer = _PyFrame_GetStackPointer(frame); - if (is_none) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } + #if MAX_CACHED_REGISTER >= 1 _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _JUMP_TO_TOP_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _POP_CALL_ONE_r30: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - JUMP_TO_JUMP_TARGET(); + _PyStackRef pop; + _PyStackRef null; + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + pop = _stack_item_2; + null = _stack_item_1; + callable = _stack_item_0; + stack_pointer[0] = callable; + stack_pointer[1] = null; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)null; + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callable); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SET_IP_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _POP_CALL_TWO_r40: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); - frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; + _PyStackRef pop2; + _PyStackRef pop1; + _PyStackRef null; + _PyStackRef callable; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + pop2 = _stack_item_3; + pop1 = _stack_item_2; + null = _stack_item_1; + callable = _stack_item_0; + stack_pointer[0] = callable; + stack_pointer[1] = null; + stack_pointer[2] = pop1; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop2); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop1); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)null; + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callable); + stack_pointer = _PyFrame_GetStackPointer(frame); + #if MAX_CACHED_REGISTER >= 1 + _tos_cache0 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SET_IP_r11: { + case _POP_TOP_LOAD_CONST_INLINE_BORROW_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef pop; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); - frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; - _tos_cache0 = _stack_item_0; + pop = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop); + stack_pointer = _PyFrame_GetStackPointer(frame); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _POP_TWO_LOAD_CONST_INLINE_BORROW_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef pop2; + _PyStackRef pop1; + _PyStackRef value; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + pop2 = _stack_item_1; + pop1 = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + stack_pointer[0] = pop1; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop2); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop1); + stack_pointer = _PyFrame_GetStackPointer(frame); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SET_IP_r22: { + case _POP_CALL_LOAD_CONST_INLINE_BORROW_r21: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef null; + _PyStackRef callable; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); - frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + null = _stack_item_1; + callable = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + (void)null; + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callable); + stack_pointer = _PyFrame_GetStackPointer(frame); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SET_IP_r33: { + case _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef pop; + _PyStackRef null; + _PyStackRef callable; + _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0_64(); - frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + pop = _stack_item_2; + null = _stack_item_1; + callable = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + stack_pointer[0] = callable; + stack_pointer[1] = null; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)null; + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callable); + stack_pointer = _PyFrame_GetStackPointer(frame); + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 + _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 + _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_STACK_SPACE_OPERAND_r00: { + case _INSERT_1_LOAD_CONST_INLINE_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); - assert(framesize <= INT_MAX); - if (!_PyThreadState_HasStackSpace(tstate, framesize)) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + left = stack_pointer[-1]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectNew(ptr); + l = left; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_STACK_SPACE_OPERAND_r11: { + case _INSERT_1_LOAD_CONST_INLINE_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; - uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); - assert(framesize <= INT_MAX); - if (!_PyThreadState_HasStackSpace(tstate, framesize)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + left = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectNew(ptr); + l = left; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_STACK_SPACE_OPERAND_r22: { + case _INSERT_1_LOAD_CONST_INLINE_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + left = _stack_item_1; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectNew(ptr); + l = left; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _INSERT_1_LOAD_CONST_INLINE_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); - assert(framesize <= INT_MAX); - if (!_PyThreadState_HasStackSpace(tstate, framesize)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_2 = _tos_cache2; + left = _stack_item_2; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectNew(ptr); + l = left; + _tos_cache3 = l; + _tos_cache2 = res; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_STACK_SPACE_OPERAND_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _INSERT_1_LOAD_CONST_INLINE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - uint32_t framesize = (uint32_t)CURRENT_OPERAND0_32(); - assert(framesize <= INT_MAX); - if (!_PyThreadState_HasStackSpace(tstate, framesize)) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_3 = _tos_cache3; + left = _stack_item_3; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectNew(ptr); + l = left; + _tos_cache4 = l; + _tos_cache3 = res; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SAVE_RETURN_OFFSET_r00: { + case _INSERT_1_LOAD_CONST_INLINE_BORROW_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - oparg = CURRENT_OPARG(); - #if TIER_ONE - frame->return_offset = (uint16_t)(next_instr - this_instr); - #endif - #if TIER_TWO - frame->return_offset = oparg; - #endif - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + left = stack_pointer[-1]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SAVE_RETURN_OFFSET_r11: { + case _INSERT_1_LOAD_CONST_INLINE_BORROW_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; - oparg = CURRENT_OPARG(); - #if TIER_ONE - frame->return_offset = (uint16_t)(next_instr - this_instr); - #endif - #if TIER_TWO - frame->return_offset = oparg; + left = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); #endif + } + + case _INSERT_1_LOAD_CONST_INLINE_BORROW_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + left = _stack_item_1; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + _tos_cache2 = l; + _tos_cache1 = res; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SAVE_RETURN_OFFSET_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _INSERT_1_LOAD_CONST_INLINE_BORROW_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - oparg = CURRENT_OPARG(); - #if TIER_ONE - frame->return_offset = (uint16_t)(next_instr - this_instr); - #endif - #if TIER_TWO - frame->return_offset = oparg; - #endif + _PyStackRef _stack_item_2 = _tos_cache2; + left = _stack_item_2; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + _tos_cache3 = l; + _tos_cache2 = res; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SAVE_RETURN_OFFSET_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _INSERT_1_LOAD_CONST_INLINE_BORROW_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - oparg = CURRENT_OPARG(); - #if TIER_ONE - frame->return_offset = (uint16_t)(next_instr - this_instr); - #endif - #if TIER_TWO - frame->return_offset = oparg; - #endif + _PyStackRef _stack_item_3 = _tos_cache3; + left = _stack_item_3; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + _tos_cache4 = l; + _tos_cache3 = res; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _EXIT_TRACE_r00: { + case _INSERT_2_LOAD_CONST_INLINE_BORROW_r03: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); - _PyExitData *exit = (_PyExitData *)exit_p; - #if defined(Py_DEBUG) && !defined(_Py_JIT) - const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) - ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) - + exit->target; - OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (frame->lltrace >= 3) { - _PyFrame_SetStackPointer(frame, stack_pointer); - printf("SIDE EXIT: [UOp "); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", - exit - current_executor->exits, exit->temperature.value_and_backoff, - (int)(target - _PyFrame_GetBytecode(frame)), - _PyOpcode_OpName[target->op.code], exit->is_control_flow); - stack_pointer = _PyFrame_GetStackPointer(frame); - } + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); #endif - tstate->jit_exit = exit; - SET_CURRENT_CACHED_VALUES(0); - TIER2_TO_TIER2(exit->executor); } - case _EXIT_TRACE_r10: { + case _INSERT_2_LOAD_CONST_INLINE_BORROW_r13: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); - _PyExitData *exit = (_PyExitData *)exit_p; - #if defined(Py_DEBUG) && !defined(_Py_JIT) - const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) - ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) - + exit->target; - OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (frame->lltrace >= 3) { - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - printf("SIDE EXIT: [UOp "); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", - exit - current_executor->exits, exit->temperature.value_and_backoff, - (int)(target - _PyFrame_GetBytecode(frame)), - _PyOpcode_OpName[target->op.code], exit->is_control_flow); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - } - #endif - tstate->jit_exit = exit; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; + right = _stack_item_0; + left = stack_pointer[-1]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - TIER2_TO_TIER2(exit->executor); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _EXIT_TRACE_r20: { + case _INSERT_2_LOAD_CONST_INLINE_BORROW_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); - _PyExitData *exit = (_PyExitData *)exit_p; - #if defined(Py_DEBUG) && !defined(_Py_JIT) - const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) - ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) - + exit->target; - OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (frame->lltrace >= 3) { - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - printf("SIDE EXIT: [UOp "); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", - exit - current_executor->exits, exit->temperature.value_and_backoff, - (int)(target - _PyFrame_GetBytecode(frame)), - _PyOpcode_OpName[target->op.code], exit->is_control_flow); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - } + right = _stack_item_1; + left = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + r = right; + _tos_cache2 = r; + _tos_cache1 = l; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); #endif - tstate->jit_exit = exit; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - TIER2_TO_TIER2(exit->executor); } - case _EXIT_TRACE_r30: { + case _INSERT_2_LOAD_CONST_INLINE_BORROW_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); - _PyExitData *exit = (_PyExitData *)exit_p; - #if defined(Py_DEBUG) && !defined(_Py_JIT) - const _Py_CODEUNIT *target = ((frame->owner == FRAME_OWNED_BY_INTERPRETER) - ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame)) - + exit->target; - OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (frame->lltrace >= 3) { - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer[2] = _stack_item_2; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - printf("SIDE EXIT: [UOp "); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n", - exit - current_executor->exits, exit->temperature.value_and_backoff, - (int)(target - _PyFrame_GetBytecode(frame)), - _PyOpcode_OpName[target->op.code], exit->is_control_flow); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -3; - } + right = _stack_item_2; + left = _stack_item_1; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + r = right; + _tos_cache3 = r; + _tos_cache2 = l; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); #endif - tstate->jit_exit = exit; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer[2] = _stack_item_2; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - TIER2_TO_TIER2(exit->executor); } - case _DYNAMIC_EXIT_r00: { + case _INSERT_2_LOAD_CONST_INLINE_BORROW_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef right; + _PyStackRef left; + _PyStackRef res; + _PyStackRef l; + _PyStackRef r; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + right = _stack_item_3; + left = _stack_item_2; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + l = left; + r = right; + _tos_cache4 = r; + _tos_cache3 = l; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); - #if defined(Py_DEBUG) && !defined(_Py_JIT) - _PyExitData *exit = (_PyExitData *)exit_p; - _Py_CODEUNIT *target = frame->instr_ptr; - OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (frame->lltrace >= 3) { - _PyFrame_SetStackPointer(frame, stack_pointer); - printf("DYNAMIC EXIT: [UOp "); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %tu, temp %d, target %d -> %s]\n", - exit - current_executor->exits, exit->temperature.value_and_backoff, - (int)(target - _PyFrame_GetBytecode(frame)), - _PyOpcode_OpName[target->op.code]); - stack_pointer = _PyFrame_GetStackPointer(frame); - } + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; + arg = stack_pointer[-1]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); #endif - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE(frame->instr_ptr); } - case _DYNAMIC_EXIT_r10: { + case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; - PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); - #if defined(Py_DEBUG) && !defined(_Py_JIT) - _PyExitData *exit = (_PyExitData *)exit_p; - _Py_CODEUNIT *target = frame->instr_ptr; - OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (frame->lltrace >= 3) { - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - printf("DYNAMIC EXIT: [UOp "); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %tu, temp %d, target %d -> %s]\n", - exit - current_executor->exits, exit->temperature.value_and_backoff, - (int)(target - _PyFrame_GetBytecode(frame)), - _PyOpcode_OpName[target->op.code]); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - } - #endif - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; + arg = _stack_item_0; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - GOTO_TIER_ONE(frame->instr_ptr); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _DYNAMIC_EXIT_r20: { + case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); - #if defined(Py_DEBUG) && !defined(_Py_JIT) - _PyExitData *exit = (_PyExitData *)exit_p; - _Py_CODEUNIT *target = frame->instr_ptr; - OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (frame->lltrace >= 3) { - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - printf("DYNAMIC EXIT: [UOp "); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %tu, temp %d, target %d -> %s]\n", - exit - current_executor->exits, exit->temperature.value_and_backoff, - (int)(target - _PyFrame_GetBytecode(frame)), - _PyOpcode_OpName[target->op.code]); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -2; - } - #endif - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; + arg = _stack_item_1; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - GOTO_TIER_ONE(frame->instr_ptr); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _DYNAMIC_EXIT_r30: { + case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - PyObject *exit_p = (PyObject *)CURRENT_OPERAND0_64(); - #if defined(Py_DEBUG) && !defined(_Py_JIT) - _PyExitData *exit = (_PyExitData *)exit_p; - _Py_CODEUNIT *target = frame->instr_ptr; - OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (frame->lltrace >= 3) { - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer[2] = _stack_item_2; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - printf("DYNAMIC EXIT: [UOp "); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %tu, temp %d, target %d -> %s]\n", - exit - current_executor->exits, exit->temperature.value_and_backoff, - (int)(target - _PyFrame_GetBytecode(frame)), - _PyOpcode_OpName[target->op.code]); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -3; - } + arg = _stack_item_2; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); #endif - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer[2] = _stack_item_2; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - GOTO_TIER_ONE(frame->instr_ptr); } - case _CHECK_VALIDITY_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - if (!current_executor->vm_data.valid) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + arg = _stack_item_3; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + _tos_cache2 = a; + _tos_cache1 = res; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_VALIDITY_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef res; + _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; - if (!current_executor->vm_data.valid) { - UOP_STAT_INC(uopcode, miss); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); - JUMP_TO_JUMP_TARGET(); - } + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + arg = _stack_item_4; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + _tos_cache3 = a; + _tos_cache2 = res; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_VALIDITY_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef callable; + _PyStackRef res; + _PyStackRef a; + _PyStackRef c; + arg = stack_pointer[-1]; + callable = stack_pointer[-3]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + c = callable; + _tos_cache2 = c; + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef callable; + _PyStackRef res; + _PyStackRef a; + _PyStackRef c; _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - if (!current_executor->vm_data.valid) { - UOP_STAT_INC(uopcode, miss); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + arg = _stack_item_0; + callable = stack_pointer[-2]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + c = callable; + _tos_cache2 = c; + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _CHECK_VALIDITY_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef arg; + _PyStackRef callable; + _PyStackRef res; + _PyStackRef a; + _PyStackRef c; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - if (!current_executor->vm_data.valid) { - UOP_STAT_INC(uopcode, miss); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); - JUMP_TO_JUMP_TARGET(); - } - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + arg = _stack_item_1; + callable = stack_pointer[-1]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + c = callable; + _tos_cache2 = c; + _tos_cache1 = a; + _tos_cache0 = res; SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_INLINE_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; + _PyStackRef arg; + _PyStackRef callable; + _PyStackRef res; + _PyStackRef a; + _PyStackRef c; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + arg = _stack_item_2; + callable = _stack_item_0; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - value = PyStackRef_FromPyObjectNew(ptr); - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + c = callable; + _tos_cache2 = c; + _tos_cache1 = a; + _tos_cache0 = res; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_INLINE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; + _PyStackRef arg; + _PyStackRef callable; + _PyStackRef res; + _PyStackRef a; + _PyStackRef c; _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + arg = _stack_item_3; + callable = _stack_item_1; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - value = PyStackRef_FromPyObjectNew(ptr); - _tos_cache1 = value; + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + c = callable; + _tos_cache3 = c; + _tos_cache2 = a; + _tos_cache1 = res; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_INLINE_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef value; + _PyStackRef arg; + _PyStackRef callable; + _PyStackRef res; + _PyStackRef a; + _PyStackRef c; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + arg = _stack_item_4; + callable = _stack_item_2; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - value = PyStackRef_FromPyObjectNew(ptr); - _tos_cache2 = value; + res = PyStackRef_FromPyObjectBorrow(ptr); + a = arg; + c = callable; + _tos_cache4 = c; + _tos_cache3 = a; + _tos_cache2 = res; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_LOAD_CONST_INLINE_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r41: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef pop; + _PyStackRef pop2; + _PyStackRef pop1; + _PyStackRef null; + _PyStackRef callable; _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; - pop = _stack_item_0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + pop2 = _stack_item_3; + pop1 = _stack_item_2; + null = _stack_item_1; + callable = _stack_item_0; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + stack_pointer[0] = callable; + stack_pointer[1] = null; + stack_pointer[2] = pop1; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop); + PyStackRef_CLOSE(pop2); stack_pointer = _PyFrame_GetStackPointer(frame); - value = PyStackRef_FromPyObjectNew(ptr); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(pop1); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)null; + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_CLOSE(callable); + stack_pointer = _PyFrame_GetStackPointer(frame); + value = PyStackRef_FromPyObjectBorrow(ptr); _tos_cache0 = value; + #if MAX_CACHED_REGISTER >= 2 _tos_cache1 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 3 _tos_cache2 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 4 + _tos_cache3 = PyStackRef_ZERO_BITS; + #endif + #if MAX_CACHED_REGISTER >= 5 + _tos_cache4 = PyStackRef_ZERO_BITS; + #endif SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_INLINE_BORROW_r01: { + case _LOAD_CONST_UNDER_INLINE_r02: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef old; _PyStackRef value; + _PyStackRef new; + old = stack_pointer[-1]; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - value = PyStackRef_FromPyObjectBorrow(ptr); + new = old; + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache1 = new; _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_INLINE_BORROW_r12: { + case _LOAD_CONST_UNDER_INLINE_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef old; _PyStackRef value; + _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; + old = _stack_item_0; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; + new = old; + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache1 = new; + _tos_cache0 = value; SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_INLINE_BORROW_r23: { + case _LOAD_CONST_UNDER_INLINE_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef old; _PyStackRef value; + _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + old = _stack_item_1; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache2 = value; - _tos_cache1 = _stack_item_1; + new = old; + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache2 = new; + _tos_cache1 = value; _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_CALL_r20: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - _PyStackRef callable; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - null = _stack_item_1; - callable = _stack_item_0; - (void)null; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _POP_CALL_ONE_r30: { + case _LOAD_CONST_UNDER_INLINE_r34: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef pop; - _PyStackRef null; - _PyStackRef callable; + _PyStackRef old; + _PyStackRef value; + _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - pop = _stack_item_2; - null = _stack_item_1; - callable = _stack_item_0; - stack_pointer[0] = callable; - stack_pointer[1] = null; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop); - stack_pointer = _PyFrame_GetStackPointer(frame); - (void)null; - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); + old = _stack_item_2; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + new = old; + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache3 = new; + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_CALL_TWO_r30: { - CHECK_CURRENT_CACHED_VALUES(3); + case _LOAD_CONST_UNDER_INLINE_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef pop2; - _PyStackRef pop1; - _PyStackRef null; - _PyStackRef callable; + _PyStackRef old; + _PyStackRef value; + _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - pop2 = _stack_item_2; - pop1 = _stack_item_1; - null = _stack_item_0; - callable = stack_pointer[-1]; - stack_pointer[0] = null; - stack_pointer[1] = pop1; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop2); - stack_pointer = _PyFrame_GetStackPointer(frame); + _PyStackRef _stack_item_3 = _tos_cache3; + old = _stack_item_3; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + new = old; + value = PyStackRef_FromPyObjectNew(ptr); + _tos_cache4 = new; + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _LOAD_CONST_UNDER_INLINE_BORROW_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef old; + _PyStackRef value; + _PyStackRef new; + old = stack_pointer[-1]; + PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); + new = old; + value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache1 = new; + _tos_cache0 = value; + SET_CURRENT_CACHED_VALUES(2); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop1); - stack_pointer = _PyFrame_GetStackPointer(frame); - (void)null; - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable); - stack_pointer = _PyFrame_GetStackPointer(frame); - _tos_cache0 = PyStackRef_ZERO_BITS; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TOP_LOAD_CONST_INLINE_BORROW_r11: { + case _LOAD_CONST_UNDER_INLINE_BORROW_r12: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef pop; + _PyStackRef old; _PyStackRef value; + _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; - pop = _stack_item_0; + old = _stack_item_0; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop); - stack_pointer = _PyFrame_GetStackPointer(frame); + new = old; value = PyStackRef_FromPyObjectBorrow(ptr); + _tos_cache1 = new; _tos_cache0 = value; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_TWO_LOAD_CONST_INLINE_BORROW_r21: { + case _LOAD_CONST_UNDER_INLINE_BORROW_r23: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef pop2; - _PyStackRef pop1; + _PyStackRef old; _PyStackRef value; + _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - pop2 = _stack_item_1; - pop1 = _stack_item_0; + old = _stack_item_1; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - stack_pointer[0] = pop1; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop2); - stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop1); - stack_pointer = _PyFrame_GetStackPointer(frame); + new = old; value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache0 = value; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache2 = new; + _tos_cache1 = value; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_CALL_LOAD_CONST_INLINE_BORROW_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _LOAD_CONST_UNDER_INLINE_BORROW_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef null; - _PyStackRef callable; + _PyStackRef old; _PyStackRef value; + _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - null = _stack_item_1; - callable = _stack_item_0; + _PyStackRef _stack_item_2 = _tos_cache2; + old = _stack_item_2; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - (void)null; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable); - stack_pointer = _PyFrame_GetStackPointer(frame); + new = old; value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache0 = value; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache3 = new; + _tos_cache2 = value; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _LOAD_CONST_UNDER_INLINE_BORROW_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef pop; - _PyStackRef null; - _PyStackRef callable; + _PyStackRef old; _PyStackRef value; + _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - pop = _stack_item_2; - null = _stack_item_1; - callable = _stack_item_0; + _PyStackRef _stack_item_3 = _tos_cache3; + old = _stack_item_3; PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - stack_pointer[0] = callable; - stack_pointer[1] = null; - stack_pointer += 2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop); - stack_pointer = _PyFrame_GetStackPointer(frame); - (void)null; - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable); - stack_pointer = _PyFrame_GetStackPointer(frame); + new = old; value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache0 = value; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache4 = new; + _tos_cache3 = value; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INSERT_1_LOAD_CONST_INLINE_r02: { + case _START_EXECUTOR_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - left = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectNew(ptr); - l = left; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + PyObject *executor = (PyObject *)CURRENT_OPERAND0_64(); + #ifndef _Py_JIT + assert(current_executor == (_PyExecutorObject*)executor); + #endif + assert(tstate->jit_exit == NULL || tstate->jit_exit->executor == current_executor); + tstate->current_executor = (PyObject *)current_executor; + if (!current_executor->vm_data.valid) { + assert(tstate->jit_exit->executor == current_executor); + assert(tstate->current_executor == executor); + _PyFrame_SetStackPointer(frame, stack_pointer); + _PyExecutor_ClearExit(tstate->jit_exit); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (true) { + UOP_STAT_INC(uopcode, miss); + SET_CURRENT_CACHED_VALUES(0); + JUMP_TO_JUMP_TARGET(); + } + } + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _INSERT_1_LOAD_CONST_INLINE_r12: { + case _MAKE_WARM_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + current_executor->vm_data.cold = false; + SET_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + } + + case _MAKE_WARM_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; - left = _stack_item_0; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectNew(ptr); - l = left; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + current_executor->vm_data.cold = false; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INSERT_1_LOAD_CONST_INLINE_r23: { + case _MAKE_WARM_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - left = _stack_item_1; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectNew(ptr); - l = left; - _tos_cache2 = l; - _tos_cache1 = res; + current_executor->vm_data.cold = false; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INSERT_1_LOAD_CONST_INLINE_BORROW_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _MAKE_WARM_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - left = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - l = left; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + current_executor->vm_data.cold = false; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INSERT_1_LOAD_CONST_INLINE_BORROW_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _MAKE_WARM_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; - left = _stack_item_0; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - l = left; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + current_executor->vm_data.cold = false; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INSERT_1_LOAD_CONST_INLINE_BORROW_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _MAKE_WARM_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - left = _stack_item_1; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - l = left; - _tos_cache2 = l; - _tos_cache1 = res; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + current_executor->vm_data.cold = false; + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INSERT_2_LOAD_CONST_INLINE_BORROW_r03: { + case _FATAL_ERROR_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; - right = stack_pointer[-1]; - left = stack_pointer[-2]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(0); + Py_FatalError("Fatal error uop executed."); + SET_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; } - case _INSERT_2_LOAD_CONST_INLINE_BORROW_r13: { + case _FATAL_ERROR_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; - right = _stack_item_0; - left = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(0); + Py_FatalError("Fatal error uop executed."); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _INSERT_2_LOAD_CONST_INLINE_BORROW_r23: { + case _FATAL_ERROR_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef right; - _PyStackRef left; - _PyStackRef res; - _PyStackRef l; - _PyStackRef r; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - right = _stack_item_1; - left = _stack_item_0; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - l = left; - r = right; - _tos_cache2 = r; - _tos_cache1 = l; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; - } - - case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r02: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; - arg = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - _tos_cache1 = a; - _tos_cache0 = res; + assert(0); + Py_FatalError("Fatal error uop executed."); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _FATAL_ERROR_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; - arg = _stack_item_0; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -2; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + assert(0); + Py_FatalError("Fatal error uop executed."); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _FATAL_ERROR_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - arg = _stack_item_1; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + assert(0); + Py_FatalError("Fatal error uop executed."); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SHUFFLE_2_LOAD_CONST_INLINE_BORROW_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _FATAL_ERROR_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef res; - _PyStackRef a; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - arg = _stack_item_2; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(2); + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + assert(0); + Py_FatalError("Fatal error uop executed."); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r03: { + case _DEOPT_r00: { CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; - arg = stack_pointer[-1]; - callable = stack_pointer[-3]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); } - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r13: { + case _DEOPT_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; _PyStackRef _stack_item_0 = _tos_cache0; - arg = _stack_item_0; - callable = stack_pointer[-2]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif } - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r23: { + case _DEOPT_r20: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - arg = _stack_item_1; - callable = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif } - case _SHUFFLE_3_LOAD_CONST_INLINE_BORROW_r33: { + case _DEOPT_r30: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef arg; - _PyStackRef callable; - _PyStackRef res; - _PyStackRef a; - _PyStackRef c; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - arg = _stack_item_2; - callable = _stack_item_0; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - res = PyStackRef_FromPyObjectBorrow(ptr); - a = arg; - c = callable; - _tos_cache2 = c; - _tos_cache1 = a; - _tos_cache0 = res; - SET_CURRENT_CACHED_VALUES(3); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif + } + + case _DEOPT_r40: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif } - case _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _DEOPT_r50: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef pop2; - _PyStackRef pop1; - _PyStackRef null; - _PyStackRef callable; - _PyStackRef value; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - pop2 = _stack_item_2; - pop1 = _stack_item_1; - null = _stack_item_0; - callable = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - stack_pointer[0] = null; - stack_pointer[1] = pop1; - stack_pointer += 2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer[4] = _stack_item_4; + stack_pointer += 5; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) + ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif + } + + case _HANDLE_PENDING_AND_DEOPT_r00: { + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop2); + int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + } + + case _HANDLE_PENDING_AND_DEOPT_r10: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(pop1); + int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)null; - stack_pointer += -2; + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif + } + + case _HANDLE_PENDING_AND_DEOPT_r20: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable); + int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache0 = value; - _tos_cache1 = PyStackRef_ZERO_BITS; - _tos_cache2 = PyStackRef_ZERO_BITS; - SET_CURRENT_CACHED_VALUES(1); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_UNDER_INLINE_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _HANDLE_PENDING_AND_DEOPT_r30: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef old; - _PyStackRef value; - _PyStackRef new; - old = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - new = old; - value = PyStackRef_FromPyObjectNew(ptr); - _tos_cache1 = new; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_UNDER_INLINE_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _HANDLE_PENDING_AND_DEOPT_r40: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef old; - _PyStackRef value; - _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; - old = _stack_item_0; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - new = old; - value = PyStackRef_FromPyObjectNew(ptr); - _tos_cache1 = new; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_UNDER_INLINE_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _HANDLE_PENDING_AND_DEOPT_r50: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef old; - _PyStackRef value; - _PyStackRef new; _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - old = _stack_item_1; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - new = old; - value = PyStackRef_FromPyObjectNew(ptr); - _tos_cache2 = new; - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer[4] = _stack_item_4; + stack_pointer += 5; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + #else + Py_UNREACHABLE(); + #endif + } + + case _ERROR_POP_N_r00: { + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - break; + oparg = CURRENT_OPARG(); + uint32_t target = (uint32_t)CURRENT_OPERAND0_32(); + assert(oparg == 0); + frame->instr_ptr = _PyFrame_GetBytecode(frame) + target; + SET_CURRENT_CACHED_VALUES(0); + GOTO_TIER_ONE(NULL); } - case _LOAD_CONST_UNDER_INLINE_BORROW_r02: { + case _SPILL_OR_RELOAD_r01: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef old; - _PyStackRef value; - _PyStackRef new; - old = stack_pointer[-1]; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - new = old; - value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache1 = new; - _tos_cache0 = value; - SET_CURRENT_CACHED_VALUES(2); + _tos_cache0 = stack_pointer[-1]; + SET_CURRENT_CACHED_VALUES(1); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _LOAD_CONST_UNDER_INLINE_BORROW_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SPILL_OR_RELOAD_r02: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef old; - _PyStackRef value; - _PyStackRef new; - _PyStackRef _stack_item_0 = _tos_cache0; - old = _stack_item_0; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - new = old; - value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache1 = new; - _tos_cache0 = value; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = stack_pointer[-2]; SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; - } - - case _LOAD_CONST_UNDER_INLINE_BORROW_r23: { - CHECK_CURRENT_CACHED_VALUES(2); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef old; - _PyStackRef value; - _PyStackRef new; - _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - old = _stack_item_1; - PyObject *ptr = (PyObject *)CURRENT_OPERAND0_64(); - new = old; - value = PyStackRef_FromPyObjectBorrow(ptr); - _tos_cache2 = new; - _tos_cache1 = value; - _tos_cache0 = _stack_item_0; + #else + Py_UNREACHABLE(); + #endif + } + + case _SPILL_OR_RELOAD_r03: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(0); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = stack_pointer[-3]; SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _START_EXECUTOR_r00: { + case _SPILL_OR_RELOAD_r04: { + #if MAX_CACHED_REGISTER >= 4 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - PyObject *executor = (PyObject *)CURRENT_OPERAND0_64(); - #ifndef _Py_JIT - assert(current_executor == (_PyExecutorObject*)executor); - #endif - assert(tstate->jit_exit == NULL || tstate->jit_exit->executor == current_executor); - tstate->current_executor = (PyObject *)current_executor; - if (!current_executor->vm_data.valid) { - assert(tstate->jit_exit->executor == current_executor); - assert(tstate->current_executor == executor); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyExecutor_ClearExit(tstate->jit_exit); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (true) { - UOP_STAT_INC(uopcode, miss); - SET_CURRENT_CACHED_VALUES(0); - JUMP_TO_JUMP_TARGET(); - } - } - SET_CURRENT_CACHED_VALUES(0); + _tos_cache3 = stack_pointer[-1]; + _tos_cache2 = stack_pointer[-2]; + _tos_cache1 = stack_pointer[-3]; + _tos_cache0 = stack_pointer[-4]; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MAKE_WARM_r00: { + case _SPILL_OR_RELOAD_r05: { + #if MAX_CACHED_REGISTER >= 5 CHECK_CURRENT_CACHED_VALUES(0); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - current_executor->vm_data.cold = false; - SET_CURRENT_CACHED_VALUES(0); + _tos_cache4 = stack_pointer[-1]; + _tos_cache3 = stack_pointer[-2]; + _tos_cache2 = stack_pointer[-3]; + _tos_cache1 = stack_pointer[-4]; + _tos_cache0 = stack_pointer[-5]; + SET_CURRENT_CACHED_VALUES(5); + stack_pointer += -5; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MAKE_WARM_r11: { + case _SPILL_OR_RELOAD_r10: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; - current_executor->vm_data.cold = false; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MAKE_WARM_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SPILL_OR_RELOAD_r12: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - current_executor->vm_data.cold = false; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + _tos_cache1 = _stack_item_0; + _tos_cache0 = stack_pointer[-1]; SET_CURRENT_CACHED_VALUES(2); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _MAKE_WARM_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SPILL_OR_RELOAD_r13: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; - _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - current_executor->vm_data.cold = false; - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = stack_pointer[-2]; SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _FATAL_ERROR_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SPILL_OR_RELOAD_r14: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - assert(0); - Py_FatalError("Fatal error uop executed."); - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef _stack_item_0 = _tos_cache0; + _tos_cache3 = _stack_item_0; + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = stack_pointer[-3]; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -3; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _FATAL_ERROR_r11: { + case _SPILL_OR_RELOAD_r15: { + #if MAX_CACHED_REGISTER >= 5 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; - assert(0); - Py_FatalError("Fatal error uop executed."); - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + _tos_cache4 = _stack_item_0; + _tos_cache3 = stack_pointer[-1]; + _tos_cache2 = stack_pointer[-2]; + _tos_cache1 = stack_pointer[-3]; + _tos_cache0 = stack_pointer[-4]; + SET_CURRENT_CACHED_VALUES(5); + stack_pointer += -4; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _FATAL_ERROR_r22: { + case _SPILL_OR_RELOAD_r20: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - assert(0); - Py_FatalError("Fatal error uop executed."); - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _FATAL_ERROR_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SPILL_OR_RELOAD_r21: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _PyStackRef _stack_item_2 = _tos_cache2; - assert(0); - Py_FatalError("Fatal error uop executed."); - _tos_cache2 = _stack_item_2; - _tos_cache1 = _stack_item_1; - _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + _tos_cache0 = _stack_item_1; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _DEOPT_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SPILL_OR_RELOAD_r23: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) - ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = stack_pointer[-1]; + SET_CURRENT_CACHED_VALUES(3); + stack_pointer += -1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _DEOPT_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SPILL_OR_RELOAD_r24: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; + _PyStackRef _stack_item_1 = _tos_cache1; + _tos_cache3 = _stack_item_1; + _tos_cache2 = _stack_item_0; + _tos_cache1 = stack_pointer[-1]; + _tos_cache0 = stack_pointer[-2]; + SET_CURRENT_CACHED_VALUES(4); + stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) - ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _DEOPT_r20: { + case _SPILL_OR_RELOAD_r25: { + #if MAX_CACHED_REGISTER >= 5 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; + _tos_cache4 = _stack_item_1; + _tos_cache3 = _stack_item_0; + _tos_cache2 = stack_pointer[-1]; + _tos_cache1 = stack_pointer[-2]; + _tos_cache0 = stack_pointer[-3]; + SET_CURRENT_CACHED_VALUES(5); + stack_pointer += -3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) - ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _DEOPT_r30: { + case _SPILL_OR_RELOAD_r30: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + SET_CURRENT_CACHED_VALUES(0); stack_pointer[0] = _stack_item_0; stack_pointer[1] = _stack_item_1; stack_pointer[2] = _stack_item_2; stack_pointer += 3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER) - ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); - } - - case _HANDLE_PENDING_AND_DEOPT_r00: { - CHECK_CURRENT_CACHED_VALUES(0); - assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _Py_HandlePending(tstate); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); - } - - case _HANDLE_PENDING_AND_DEOPT_r10: { - CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _PyStackRef _stack_item_0 = _tos_cache0; - stack_pointer[0] = _stack_item_0; - stack_pointer += 1; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _Py_HandlePending(tstate); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _HANDLE_PENDING_AND_DEOPT_r20: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SPILL_OR_RELOAD_r31: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _tos_cache0 = _stack_item_2; + SET_CURRENT_CACHED_VALUES(1); stack_pointer[0] = _stack_item_0; stack_pointer[1] = _stack_item_1; stack_pointer += 2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _Py_HandlePending(tstate); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } - case _HANDLE_PENDING_AND_DEOPT_r30: { + case _SPILL_OR_RELOAD_r32: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer[2] = _stack_item_2; - stack_pointer += 3; - ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _Py_HandlePending(tstate); - stack_pointer = _PyFrame_GetStackPointer(frame); - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET()); - } - - case _ERROR_POP_N_r00: { - CHECK_CURRENT_CACHED_VALUES(0); + _tos_cache1 = _stack_item_2; + _tos_cache0 = _stack_item_1; + SET_CURRENT_CACHED_VALUES(2); + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; + ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - oparg = CURRENT_OPARG(); - uint32_t target = (uint32_t)CURRENT_OPERAND0_32(); - assert(oparg == 0); - frame->instr_ptr = _PyFrame_GetBytecode(frame) + target; - SET_CURRENT_CACHED_VALUES(0); - GOTO_TIER_ONE(NULL); + break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r01: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SPILL_OR_RELOAD_r34: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _tos_cache3 = _stack_item_2; + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; _tos_cache0 = stack_pointer[-1]; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(4); stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r02: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SPILL_OR_RELOAD_r35: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _tos_cache4 = _stack_item_2; + _tos_cache3 = _stack_item_1; + _tos_cache2 = _stack_item_0; _tos_cache1 = stack_pointer[-1]; _tos_cache0 = stack_pointer[-2]; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(5); stack_pointer += -2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r03: { - CHECK_CURRENT_CACHED_VALUES(0); + case _SPILL_OR_RELOAD_r40: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); - _tos_cache2 = stack_pointer[-1]; - _tos_cache1 = stack_pointer[-2]; - _tos_cache0 = stack_pointer[-3]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -3; + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + SET_CURRENT_CACHED_VALUES(0); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r10: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SPILL_OR_RELOAD_r41: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _tos_cache0 = _stack_item_3; + SET_CURRENT_CACHED_VALUES(1); stack_pointer[0] = _stack_item_0; - stack_pointer += 1; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer += 3; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r12: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SPILL_OR_RELOAD_r42: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; - _tos_cache1 = _stack_item_0; - _tos_cache0 = stack_pointer[-1]; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _tos_cache1 = _stack_item_3; + _tos_cache0 = _stack_item_2; SET_CURRENT_CACHED_VALUES(2); - stack_pointer += -1; + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer += 2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r13: { - CHECK_CURRENT_CACHED_VALUES(1); + case _SPILL_OR_RELOAD_r43: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; - _tos_cache2 = _stack_item_0; - _tos_cache1 = stack_pointer[-1]; - _tos_cache0 = stack_pointer[-2]; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _tos_cache2 = _stack_item_3; + _tos_cache1 = _stack_item_2; + _tos_cache0 = _stack_item_1; SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -2; + stack_pointer[0] = _stack_item_0; + stack_pointer += 1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r20: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SPILL_OR_RELOAD_r45: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - SET_CURRENT_CACHED_VALUES(0); - stack_pointer[0] = _stack_item_0; - stack_pointer[1] = _stack_item_1; - stack_pointer += 2; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _tos_cache4 = _stack_item_3; + _tos_cache3 = _stack_item_2; + _tos_cache2 = _stack_item_1; + _tos_cache1 = _stack_item_0; + _tos_cache0 = stack_pointer[-1]; + SET_CURRENT_CACHED_VALUES(5); + stack_pointer += -1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r21: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SPILL_OR_RELOAD_r50: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _tos_cache0 = _stack_item_1; - SET_CURRENT_CACHED_VALUES(1); + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + SET_CURRENT_CACHED_VALUES(0); stack_pointer[0] = _stack_item_0; - stack_pointer += 1; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer[4] = _stack_item_4; + stack_pointer += 5; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r23: { - CHECK_CURRENT_CACHED_VALUES(2); + case _SPILL_OR_RELOAD_r51: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; - _tos_cache2 = _stack_item_1; - _tos_cache1 = _stack_item_0; - _tos_cache0 = stack_pointer[-1]; - SET_CURRENT_CACHED_VALUES(3); - stack_pointer += -1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + _tos_cache0 = _stack_item_4; + SET_CURRENT_CACHED_VALUES(1); + stack_pointer[0] = _stack_item_0; + stack_pointer[1] = _stack_item_1; + stack_pointer[2] = _stack_item_2; + stack_pointer[3] = _stack_item_3; + stack_pointer += 4; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r30: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SPILL_OR_RELOAD_r52: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; - SET_CURRENT_CACHED_VALUES(0); + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + _tos_cache1 = _stack_item_4; + _tos_cache0 = _stack_item_3; + SET_CURRENT_CACHED_VALUES(2); stack_pointer[0] = _stack_item_0; stack_pointer[1] = _stack_item_1; stack_pointer[2] = _stack_item_2; @@ -20462,38 +36052,57 @@ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r31: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SPILL_OR_RELOAD_r53: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + _tos_cache2 = _stack_item_4; + _tos_cache1 = _stack_item_3; _tos_cache0 = _stack_item_2; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); stack_pointer[0] = _stack_item_0; stack_pointer[1] = _stack_item_1; stack_pointer += 2; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _SPILL_OR_RELOAD_r32: { - CHECK_CURRENT_CACHED_VALUES(3); + case _SPILL_OR_RELOAD_r54: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + _tos_cache3 = _stack_item_4; + _tos_cache2 = _stack_item_3; _tos_cache1 = _stack_item_2; _tos_cache0 = _stack_item_1; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); stack_pointer[0] = _stack_item_0; stack_pointer += 1; ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _TIER2_RESUME_CHECK_r00: { @@ -20520,6 +36129,7 @@ } case _TIER2_RESUME_CHECK_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20544,9 +36154,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _TIER2_RESUME_CHECK_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20575,9 +36189,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _TIER2_RESUME_CHECK_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20610,6 +36228,99 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _TIER2_RESUME_CHECK_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + #if defined(__EMSCRIPTEN__) + if (_Py_emscripten_signal_clock == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _Py_emscripten_signal_clock -= Py_EMSCRIPTEN_SIGNAL_HANDLING; + #endif + uintptr_t iversion = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); + uintptr_t eval_breaker = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker); + if (eval_breaker != iversion) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _TIER2_RESUME_CHECK_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + #if defined(__EMSCRIPTEN__) + if (_Py_emscripten_signal_clock == 0) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _Py_emscripten_signal_clock -= Py_EMSCRIPTEN_SIGNAL_HANDLING; + #endif + uintptr_t iversion = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); + uintptr_t eval_breaker = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker); + if (eval_breaker != iversion) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } case _COLD_EXIT_r00: { @@ -20673,70 +36384,149 @@ break; } - case _GUARD_CODE_VERSION_r11: { - CHECK_CURRENT_CACHED_VALUES(1); + case _GUARD_CODE_VERSION_r11: { + #if MAX_CACHED_REGISTER >= 1 + CHECK_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + uint32_t version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *code = PyStackRef_AsPyObjectBorrow(frame->f_executable); + assert(PyCode_Check(code)); + if (((PyCodeObject *)code)->co_version != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(1); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CODE_VERSION_r22: { + #if MAX_CACHED_REGISTER >= 2 + CHECK_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + uint32_t version = (uint32_t)CURRENT_OPERAND0_32(); + PyObject *code = PyStackRef_AsPyObjectBorrow(frame->f_executable); + assert(PyCode_Check(code)); + if (((PyCodeObject *)code)->co_version != version) { + UOP_STAT_INC(uopcode, miss); + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + JUMP_TO_JUMP_TARGET(); + } + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(2); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_CODE_VERSION_r33: { + #if MAX_CACHED_REGISTER >= 3 + CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; uint32_t version = (uint32_t)CURRENT_OPERAND0_32(); PyObject *code = PyStackRef_AsPyObjectBorrow(frame->f_executable); assert(PyCode_Check(code)); if (((PyCodeObject *)code)->co_version != version) { UOP_STAT_INC(uopcode, miss); + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); JUMP_TO_JUMP_TARGET(); } + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(1); + SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CODE_VERSION_r22: { - CHECK_CURRENT_CACHED_VALUES(2); + case _GUARD_CODE_VERSION_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; uint32_t version = (uint32_t)CURRENT_OPERAND0_32(); PyObject *code = PyStackRef_AsPyObjectBorrow(frame->f_executable); assert(PyCode_Check(code)); if (((PyCodeObject *)code)->co_version != version) { UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); JUMP_TO_JUMP_TARGET(); } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(2); + SET_CURRENT_CACHED_VALUES(4); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } - case _GUARD_CODE_VERSION_r33: { - CHECK_CURRENT_CACHED_VALUES(3); + case _GUARD_CODE_VERSION_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; _PyStackRef _stack_item_1 = _tos_cache1; _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; uint32_t version = (uint32_t)CURRENT_OPERAND0_32(); PyObject *code = PyStackRef_AsPyObjectBorrow(frame->f_executable); assert(PyCode_Check(code)); if (((PyCodeObject *)code)->co_version != version) { UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); JUMP_TO_JUMP_TARGET(); } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; _tos_cache2 = _stack_item_2; _tos_cache1 = _stack_item_1; _tos_cache0 = _stack_item_0; - SET_CURRENT_CACHED_VALUES(3); + SET_CURRENT_CACHED_VALUES(5); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP__PUSH_FRAME_r00: { @@ -20757,6 +36547,7 @@ } case _GUARD_IP__PUSH_FRAME_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20774,9 +36565,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP__PUSH_FRAME_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20797,9 +36592,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP__PUSH_FRAME_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20823,6 +36622,78 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IP__PUSH_FRAME_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *ip = (PyObject *)CURRENT_OPERAND0_64(); + _Py_CODEUNIT *target = frame->instr_ptr; + if (target != (_Py_CODEUNIT *)ip) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IP__PUSH_FRAME_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + PyObject *ip = (PyObject *)CURRENT_OPERAND0_64(); + _Py_CODEUNIT *target = frame->instr_ptr; + if (target != (_Py_CODEUNIT *)ip) { + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_YIELD_VALUE_r00: { @@ -20844,6 +36715,7 @@ } case _GUARD_IP_YIELD_VALUE_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20862,9 +36734,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_YIELD_VALUE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20886,9 +36762,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_YIELD_VALUE_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20913,6 +36793,80 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IP_YIELD_VALUE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *ip = (PyObject *)CURRENT_OPERAND0_64(); + _Py_CODEUNIT *target = frame->instr_ptr + 1 + INLINE_CACHE_ENTRIES_SEND; + if (target != (_Py_CODEUNIT *)ip) { + frame->instr_ptr += 1 + INLINE_CACHE_ENTRIES_SEND; + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IP_YIELD_VALUE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + PyObject *ip = (PyObject *)CURRENT_OPERAND0_64(); + _Py_CODEUNIT *target = frame->instr_ptr + 1 + INLINE_CACHE_ENTRIES_SEND; + if (target != (_Py_CODEUNIT *)ip) { + frame->instr_ptr += 1 + INLINE_CACHE_ENTRIES_SEND; + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_RETURN_VALUE_r00: { @@ -20934,6 +36888,7 @@ } case _GUARD_IP_RETURN_VALUE_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20952,9 +36907,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_RETURN_VALUE_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -20976,9 +36935,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_RETURN_VALUE_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -21003,6 +36966,80 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IP_RETURN_VALUE_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *ip = (PyObject *)CURRENT_OPERAND0_64(); + _Py_CODEUNIT *target = frame->instr_ptr + frame->return_offset; + if (target != (_Py_CODEUNIT *)ip) { + frame->instr_ptr += frame->return_offset; + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IP_RETURN_VALUE_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + PyObject *ip = (PyObject *)CURRENT_OPERAND0_64(); + _Py_CODEUNIT *target = frame->instr_ptr + frame->return_offset; + if (target != (_Py_CODEUNIT *)ip) { + frame->instr_ptr += frame->return_offset; + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_RETURN_GENERATOR_r00: { @@ -21024,6 +37061,7 @@ } case _GUARD_IP_RETURN_GENERATOR_r11: { + #if MAX_CACHED_REGISTER >= 1 CHECK_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -21042,9 +37080,13 @@ SET_CURRENT_CACHED_VALUES(1); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_RETURN_GENERATOR_r22: { + #if MAX_CACHED_REGISTER >= 2 CHECK_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -21066,9 +37108,13 @@ SET_CURRENT_CACHED_VALUES(2); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif } case _GUARD_IP_RETURN_GENERATOR_r33: { + #if MAX_CACHED_REGISTER >= 3 CHECK_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); _PyStackRef _stack_item_0 = _tos_cache0; @@ -21093,6 +37139,80 @@ SET_CURRENT_CACHED_VALUES(3); assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IP_RETURN_GENERATOR_r44: { + #if MAX_CACHED_REGISTER >= 4 + CHECK_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + PyObject *ip = (PyObject *)CURRENT_OPERAND0_64(); + _Py_CODEUNIT *target = frame->instr_ptr + frame->return_offset; + if (target != (_Py_CODEUNIT *)ip) { + frame->instr_ptr += frame->return_offset; + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(4); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif + } + + case _GUARD_IP_RETURN_GENERATOR_r55: { + #if MAX_CACHED_REGISTER >= 5 + CHECK_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + _PyStackRef _stack_item_0 = _tos_cache0; + _PyStackRef _stack_item_1 = _tos_cache1; + _PyStackRef _stack_item_2 = _tos_cache2; + _PyStackRef _stack_item_3 = _tos_cache3; + _PyStackRef _stack_item_4 = _tos_cache4; + PyObject *ip = (PyObject *)CURRENT_OPERAND0_64(); + _Py_CODEUNIT *target = frame->instr_ptr + frame->return_offset; + if (target != (_Py_CODEUNIT *)ip) { + frame->instr_ptr += frame->return_offset; + if (true) { + UOP_STAT_INC(uopcode, miss); + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + JUMP_TO_JUMP_TARGET(); + } + } + _tos_cache4 = _stack_item_4; + _tos_cache3 = _stack_item_3; + _tos_cache2 = _stack_item_2; + _tos_cache1 = _stack_item_1; + _tos_cache0 = _stack_item_0; + SET_CURRENT_CACHED_VALUES(5); + assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE()); + break; + #else + Py_UNREACHABLE(); + #endif } /* _TRACE_RECORD is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 89f843644329ec..c7a264193a57a5 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -7,7 +7,8 @@ from parser import Stmt, SimpleStmt, BlockStmt, IfStmt, WhileStmt, ForStmt, MacroIfStmt -MAX_CACHED_REGISTER = 3 +MAX_GENERATED_CACHED_REGISTER = 5 +MAX_CACHED_REGISTER = 3 # Platform-specific; controls compile-time case pruning @dataclass class EscapingCall: @@ -1369,13 +1370,13 @@ def is_large(uop: Uop) -> bool: def get_uop_cache_depths(uop: Uop) -> Iterator[tuple[int, int, int]]: if uop.name == "_SPILL_OR_RELOAD": - for inputs in range(MAX_CACHED_REGISTER+1): - for outputs in range(MAX_CACHED_REGISTER+1): + for inputs in range(MAX_GENERATED_CACHED_REGISTER + 1): + for outputs in range(MAX_GENERATED_CACHED_REGISTER + 1): if inputs != outputs: yield inputs, outputs, inputs return if uop.name in ("_DEOPT", "_HANDLE_PENDING_AND_DEOPT", "_EXIT_TRACE", "_DYNAMIC_EXIT"): - for i in range(MAX_CACHED_REGISTER+1): + for i in range(MAX_GENERATED_CACHED_REGISTER + 1): yield i, 0, 0 return if uop.name in ("_START_EXECUTOR", "_JUMP_TO_TOP", "_COLD_EXIT"): @@ -1397,20 +1398,20 @@ def get_uop_cache_depths(uop: Uop) -> Iterator[tuple[int, int, int]]: has_array = True break ideal_outputs += 1 - if ideal_inputs > MAX_CACHED_REGISTER: - ideal_inputs = MAX_CACHED_REGISTER - if ideal_outputs > MAX_CACHED_REGISTER: - ideal_outputs = MAX_CACHED_REGISTER + if ideal_inputs > MAX_GENERATED_CACHED_REGISTER: + ideal_inputs = MAX_GENERATED_CACHED_REGISTER + if ideal_outputs > MAX_GENERATED_CACHED_REGISTER: + ideal_outputs = MAX_GENERATED_CACHED_REGISTER at_end = uop.properties.sync_sp or uop.properties.side_exit_at_end exit_depth = ideal_outputs if at_end else ideal_inputs if uop.properties.escapes or uop.properties.sync_sp or has_array or is_large(uop): yield ideal_inputs, ideal_outputs, exit_depth return - for inputs in range(MAX_CACHED_REGISTER + 1): + for inputs in range(MAX_GENERATED_CACHED_REGISTER + 1): outputs = ideal_outputs - ideal_inputs + inputs if outputs < ideal_outputs: outputs = ideal_outputs - elif outputs > MAX_CACHED_REGISTER: + elif outputs > MAX_GENERATED_CACHED_REGISTER: continue yield inputs, outputs, outputs if at_end else inputs diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 12da5bff254957..8838f939dbc21f 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -16,7 +16,7 @@ analysis_error, get_uop_cache_depths, is_large, - MAX_CACHED_REGISTER, + MAX_GENERATED_CACHED_REGISTER, ) from generators_common import ( @@ -202,8 +202,10 @@ def cache_items(self, stack: Stack, cached_items: int, zero_regs: bool) -> None: # replace this with a "clobber" to tell # the compiler that these values are unused # without having to emit any code. - for i in range(cached_items, MAX_CACHED_REGISTER): + for i in range(cached_items, MAX_GENERATED_CACHED_REGISTER): + self.out.emit(f"#if MAX_CACHED_REGISTER >= {i + 1}\n") self.out.emit(f"_tos_cache{i} = PyStackRef_ZERO_BITS;\n") + self.out.emit("#endif\n") self.emit(f"SET_CURRENT_CACHED_VALUES({cached_items});\n") @@ -277,7 +279,11 @@ def generate_tier2( continue for inputs, outputs, exit_depth in get_uop_cache_depths(uop): emitter = Tier2Emitter(out, analysis.labels, exit_depth) - out.emit(f"case {uop.name}_r{inputs}{outputs}: {{\n") + opname = f"{uop.name}_r{inputs}{outputs}" + needed_cached_registers = max(inputs, outputs) + out.emit(f"case {opname}: {{\n") + if needed_cached_registers: + out.emit(f"#if MAX_CACHED_REGISTER >= {needed_cached_registers}\n") out.emit(f"CHECK_CURRENT_CACHED_VALUES({inputs});\n") out.emit("assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE());\n") declare_variables(uop, out) @@ -290,6 +296,10 @@ def generate_tier2( out.emit("assert(WITHIN_STACK_BOUNDS_IGNORING_CACHE());\n") if not uop.properties.always_exits: out.emit("break;\n") + if needed_cached_registers: + out.emit("#else\n") + out.emit("Py_UNREACHABLE();\n") + out.emit("#endif\n") out.start_line() out.emit("}") out.emit("\n\n") diff --git a/Tools/cases_generator/uop_id_generator.py b/Tools/cases_generator/uop_id_generator.py index b059a4a169c1ae..b38fc27ce34fba 100644 --- a/Tools/cases_generator/uop_id_generator.py +++ b/Tools/cases_generator/uop_id_generator.py @@ -9,6 +9,7 @@ Analysis, analyze_files, get_uop_cache_depths, + MAX_CACHED_REGISTER, ) from generators_common import ( DEFAULT_INPUT, @@ -48,6 +49,7 @@ def generate_uop_ids( next_id += 1 out.emit(f"#define MAX_UOP_ID {next_id-1}\n") + out.emit(f"#define MAX_CACHED_REGISTER {MAX_CACHED_REGISTER}\n") for name, uop in sorted(uops): if uop.properties.tier == 1: continue diff --git a/Tools/cases_generator/uop_metadata_generator.py b/Tools/cases_generator/uop_metadata_generator.py index 4c24435cbdbe05..d604fa54e00007 100644 --- a/Tools/cases_generator/uop_metadata_generator.py +++ b/Tools/cases_generator/uop_metadata_generator.py @@ -37,6 +37,8 @@ def uop_cache_info(uop: Uop) -> list[str] | None: high = -1 defined = [ False ] * 4 for inputs, outputs, exit_depth in get_uop_cache_depths(uop): + if max(inputs, outputs) > MAX_CACHED_REGISTER: + continue entries[inputs] = f"{{ {outputs}, {exit_depth}, {uop.name}_r{inputs}{outputs} }},\n" if inputs < low: low = inputs @@ -63,7 +65,6 @@ def uop_cache_info(uop: Uop) -> list[str] | None: def generate_names_and_flags(analysis: Analysis, out: CWriter) -> None: - out.emit(f"#define MAX_CACHED_REGISTER {MAX_CACHED_REGISTER}\n") out.emit("extern const uint32_t _PyUop_Flags[MAX_UOP_ID+1];\n") out.emit("typedef struct _rep_range { uint8_t start; uint8_t stop; } ReplicationRange;\n") out.emit("extern const ReplicationRange _PyUop_Replication[MAX_UOP_ID+1];\n")