#include <stdint.h>
#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];
-extern const char * const _PyOpcode_uop_name[MAX_UOP_ID+1];
+extern const char * const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1];
extern int _PyUop_num_popped(int opcode, int oparg);
+typedef struct _pyuop_tos_cache_entry {
+ /* input depth is implicit in position */
+ int8_t output;
+ int8_t exit;
+ int16_t opcode;
+} _PyUopTOSentry;
+typedef struct _PyUopCachingInfo {
+ uint8_t best[MAX_CACHED_REGISTER + 1];
+ _PyUopTOSentry entries[MAX_CACHED_REGISTER + 1];
+} _PyUopCachingInfo;
+extern const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1];
+extern const uint16_t _PyUop_SpillsAndReloads[4][4];
+extern const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1];
+
#ifdef NEED_OPCODE_METADATA
const uint32_t _PyUop_Flags[MAX_UOP_ID+1] = {
[_NOP] = HAS_PURE_FLAG,
[_LOAD_FAST_BORROW_7] = HAS_LOCAL_FLAG | HAS_PURE_FLAG,
[_LOAD_FAST_BORROW] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_PURE_FLAG,
[_LOAD_FAST_AND_CLEAR] = HAS_ARG_FLAG | HAS_LOCAL_FLAG,
- [_LOAD_FAST_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG,
- [_LOAD_FAST_BORROW_LOAD_FAST_BORROW] = HAS_ARG_FLAG | HAS_LOCAL_FLAG,
[_LOAD_CONST] = HAS_ARG_FLAG | HAS_CONST_FLAG,
[_LOAD_SMALL_INT_0] = 0,
[_LOAD_SMALL_INT_1] = 0,
[_STORE_FAST_6] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG,
[_STORE_FAST_7] = HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG,
[_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG,
- [_STORE_FAST_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG,
- [_STORE_FAST_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG,
[_POP_TOP] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG,
[_POP_TOP_NOP] = 0,
[_POP_TOP_INT] = 0,
[_CHECK_ATTR_METHOD_LAZY_DICT] = HAS_DEOPT_FLAG,
[_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ARG_FLAG,
[_MAYBE_EXPAND_METHOD] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG,
- [_PY_FRAME_GENERAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
+ [_PY_FRAME_GENERAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG,
[_CHECK_FUNCTION_VERSION] = HAS_ARG_FLAG | HAS_EXIT_FLAG,
[_CHECK_FUNCTION_VERSION_INLINE] = HAS_EXIT_FLAG,
[_CHECK_METHOD_VERSION] = HAS_ARG_FLAG | HAS_EXIT_FLAG,
[_INIT_CALL_PY_EXACT_ARGS_3] = HAS_PURE_FLAG,
[_INIT_CALL_PY_EXACT_ARGS_4] = HAS_PURE_FLAG,
[_INIT_CALL_PY_EXACT_ARGS] = HAS_ARG_FLAG | HAS_PURE_FLAG,
- [_PUSH_FRAME] = HAS_NEEDS_GUARD_IP_FLAG,
+ [_PUSH_FRAME] = HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG,
[_GUARD_NOS_NULL] = HAS_DEOPT_FLAG,
[_GUARD_NOS_NOT_NULL] = HAS_EXIT_FLAG,
[_GUARD_THIRD_NULL] = HAS_DEOPT_FLAG,
[_GUARD_CALLABLE_TUPLE_1] = HAS_DEOPT_FLAG,
[_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
- [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
+ [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG,
[_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_MAYBE_EXPAND_METHOD_KW] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG,
- [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
+ [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG,
[_CHECK_FUNCTION_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG,
[_CHECK_METHOD_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG,
[_EXPAND_METHOD_KW] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG,
[_START_EXECUTOR] = HAS_DEOPT_FLAG,
[_MAKE_WARM] = 0,
[_FATAL_ERROR] = 0,
- [_DEOPT] = 0,
- [_HANDLE_PENDING_AND_DEOPT] = HAS_ESCAPES_FLAG,
- [_ERROR_POP_N] = HAS_ARG_FLAG,
+ [_DEOPT] = HAS_SYNC_SP_FLAG,
+ [_HANDLE_PENDING_AND_DEOPT] = HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG,
+ [_ERROR_POP_N] = HAS_ARG_FLAG | HAS_SYNC_SP_FLAG,
+ [_SPILL_OR_RELOAD] = 0,
[_TIER2_RESUME_CHECK] = HAS_PERIODIC_FLAG,
- [_COLD_EXIT] = 0,
- [_COLD_DYNAMIC_EXIT] = 0,
+ [_COLD_EXIT] = HAS_SYNC_SP_FLAG,
+ [_COLD_DYNAMIC_EXIT] = HAS_SYNC_SP_FLAG,
[_GUARD_IP__PUSH_FRAME] = HAS_EXIT_FLAG,
[_GUARD_IP_YIELD_VALUE] = HAS_EXIT_FLAG,
[_GUARD_IP_RETURN_VALUE] = HAS_EXIT_FLAG,
[_SWAP] = { 2, 4 },
};
-const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = {
+const _PyUopCachingInfo _PyUop_Caching[MAX_UOP_ID+1] = {
+ [_NOP] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _NOP_r00 },
+ { 1, 1, _NOP_r11 },
+ { 2, 2, _NOP_r22 },
+ { 3, 3, _NOP_r33 },
+ },
+ },
+ [_CHECK_PERIODIC] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_PERIODIC_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_PERIODIC_IF_NOT_YIELD_FROM] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_RESUME_CHECK] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _RESUME_CHECK_r00 },
+ { 1, 1, _RESUME_CHECK_r11 },
+ { 2, 2, _RESUME_CHECK_r22 },
+ { 3, 3, _RESUME_CHECK_r33 },
+ },
+ },
+ [_LOAD_FAST_CHECK] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_CHECK_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_0] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_0_r01 },
+ { 2, 1, _LOAD_FAST_0_r12 },
+ { 3, 2, _LOAD_FAST_0_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_1] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_1_r01 },
+ { 2, 1, _LOAD_FAST_1_r12 },
+ { 3, 2, _LOAD_FAST_1_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_2] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_2_r01 },
+ { 2, 1, _LOAD_FAST_2_r12 },
+ { 3, 2, _LOAD_FAST_2_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_3] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_3_r01 },
+ { 2, 1, _LOAD_FAST_3_r12 },
+ { 3, 2, _LOAD_FAST_3_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_4] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_4_r01 },
+ { 2, 1, _LOAD_FAST_4_r12 },
+ { 3, 2, _LOAD_FAST_4_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_5] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_5_r01 },
+ { 2, 1, _LOAD_FAST_5_r12 },
+ { 3, 2, _LOAD_FAST_5_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_6] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_6_r01 },
+ { 2, 1, _LOAD_FAST_6_r12 },
+ { 3, 2, _LOAD_FAST_6_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_7] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_7_r01 },
+ { 2, 1, _LOAD_FAST_7_r12 },
+ { 3, 2, _LOAD_FAST_7_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_r01 },
+ { 2, 1, _LOAD_FAST_r12 },
+ { 3, 2, _LOAD_FAST_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW_0] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_0_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_0_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_0_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW_1] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_1_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_1_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_1_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW_2] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_2_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_2_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_2_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW_3] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_3_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_3_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_3_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW_4] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_4_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_4_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_4_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW_5] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_5_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_5_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_5_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW_6] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_6_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_6_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_6_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW_7] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_7_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_7_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_7_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_BORROW] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_BORROW_r01 },
+ { 2, 1, _LOAD_FAST_BORROW_r12 },
+ { 3, 2, _LOAD_FAST_BORROW_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FAST_AND_CLEAR] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_FAST_AND_CLEAR_r01 },
+ { 2, 1, _LOAD_FAST_AND_CLEAR_r12 },
+ { 3, 2, _LOAD_FAST_AND_CLEAR_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_CONST] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_CONST_r01 },
+ { 2, 1, _LOAD_CONST_r12 },
+ { 3, 2, _LOAD_CONST_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_SMALL_INT_0] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_SMALL_INT_0_r01 },
+ { 2, 1, _LOAD_SMALL_INT_0_r12 },
+ { 3, 2, _LOAD_SMALL_INT_0_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_SMALL_INT_1] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_SMALL_INT_1_r01 },
+ { 2, 1, _LOAD_SMALL_INT_1_r12 },
+ { 3, 2, _LOAD_SMALL_INT_1_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_SMALL_INT_2] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_SMALL_INT_2_r01 },
+ { 2, 1, _LOAD_SMALL_INT_2_r12 },
+ { 3, 2, _LOAD_SMALL_INT_2_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_SMALL_INT_3] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_SMALL_INT_3_r01 },
+ { 2, 1, _LOAD_SMALL_INT_3_r12 },
+ { 3, 2, _LOAD_SMALL_INT_3_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_SMALL_INT] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_SMALL_INT_r01 },
+ { 2, 1, _LOAD_SMALL_INT_r12 },
+ { 3, 2, _LOAD_SMALL_INT_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST_0] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_0_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST_1] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_1_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST_2] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_2_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST_3] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_3_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST_4] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_4_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST_5] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_5_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST_6] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_6_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST_7] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_7_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_FAST] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _STORE_FAST_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_TOP] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _POP_TOP_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_TOP_NOP] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _POP_TOP_NOP_r00 },
+ { 0, 1, _POP_TOP_NOP_r10 },
+ { 1, 2, _POP_TOP_NOP_r21 },
+ { 2, 3, _POP_TOP_NOP_r32 },
+ },
+ },
+ [_POP_TOP_INT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _POP_TOP_INT_r00 },
+ { 0, 1, _POP_TOP_INT_r10 },
+ { 1, 2, _POP_TOP_INT_r21 },
+ { 2, 3, _POP_TOP_INT_r32 },
+ },
+ },
+ [_POP_TOP_FLOAT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _POP_TOP_FLOAT_r00 },
+ { 0, 1, _POP_TOP_FLOAT_r10 },
+ { 1, 2, _POP_TOP_FLOAT_r21 },
+ { 2, 3, _POP_TOP_FLOAT_r32 },
+ },
+ },
+ [_POP_TOP_UNICODE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _POP_TOP_UNICODE_r00 },
+ { 0, 1, _POP_TOP_UNICODE_r10 },
+ { 1, 2, _POP_TOP_UNICODE_r21 },
+ { 2, 3, _POP_TOP_UNICODE_r32 },
+ },
+ },
+ [_POP_TWO] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 2, _POP_TWO_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_PUSH_NULL] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _PUSH_NULL_r01 },
+ { 2, 1, _PUSH_NULL_r12 },
+ { 3, 2, _PUSH_NULL_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_END_FOR] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _END_FOR_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_ITER] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 2, _POP_ITER_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_END_SEND] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 2, _END_SEND_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_UNARY_NEGATIVE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _UNARY_NEGATIVE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_UNARY_NOT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _UNARY_NOT_r01 },
+ { 1, 1, _UNARY_NOT_r11 },
+ { 2, 2, _UNARY_NOT_r22 },
+ { 3, 3, _UNARY_NOT_r33 },
+ },
+ },
+ [_TO_BOOL] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _TO_BOOL_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_TO_BOOL_BOOL] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _TO_BOOL_BOOL_r01 },
+ { 1, 1, _TO_BOOL_BOOL_r11 },
+ { 2, 2, _TO_BOOL_BOOL_r22 },
+ { 3, 3, _TO_BOOL_BOOL_r33 },
+ },
+ },
+ [_TO_BOOL_INT] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _TO_BOOL_INT_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_NOS_LIST] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_LIST_r02 },
+ { 2, 1, _GUARD_NOS_LIST_r12 },
+ { 2, 2, _GUARD_NOS_LIST_r22 },
+ { 3, 3, _GUARD_NOS_LIST_r33 },
+ },
+ },
+ [_GUARD_TOS_LIST] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_LIST_r01 },
+ { 1, 1, _GUARD_TOS_LIST_r11 },
+ { 2, 2, _GUARD_TOS_LIST_r22 },
+ { 3, 3, _GUARD_TOS_LIST_r33 },
+ },
+ },
+ [_GUARD_TOS_SLICE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_SLICE_r01 },
+ { 1, 1, _GUARD_TOS_SLICE_r11 },
+ { 2, 2, _GUARD_TOS_SLICE_r22 },
+ { 3, 3, _GUARD_TOS_SLICE_r33 },
+ },
+ },
+ [_TO_BOOL_LIST] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _TO_BOOL_LIST_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_TO_BOOL_NONE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _TO_BOOL_NONE_r01 },
+ { 1, 1, _TO_BOOL_NONE_r11 },
+ { 2, 2, _TO_BOOL_NONE_r22 },
+ { 3, 3, _TO_BOOL_NONE_r33 },
+ },
+ },
+ [_GUARD_NOS_UNICODE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_UNICODE_r02 },
+ { 2, 1, _GUARD_NOS_UNICODE_r12 },
+ { 2, 2, _GUARD_NOS_UNICODE_r22 },
+ { 3, 3, _GUARD_NOS_UNICODE_r33 },
+ },
+ },
+ [_GUARD_TOS_UNICODE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_UNICODE_r01 },
+ { 1, 1, _GUARD_TOS_UNICODE_r11 },
+ { 2, 2, _GUARD_TOS_UNICODE_r22 },
+ { 3, 3, _GUARD_TOS_UNICODE_r33 },
+ },
+ },
+ [_TO_BOOL_STR] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _TO_BOOL_STR_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_REPLACE_WITH_TRUE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _REPLACE_WITH_TRUE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_UNARY_INVERT] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _UNARY_INVERT_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_NOS_INT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_INT_r02 },
+ { 2, 1, _GUARD_NOS_INT_r12 },
+ { 2, 2, _GUARD_NOS_INT_r22 },
+ { 3, 3, _GUARD_NOS_INT_r33 },
+ },
+ },
+ [_GUARD_TOS_INT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_INT_r01 },
+ { 1, 1, _GUARD_TOS_INT_r11 },
+ { 2, 2, _GUARD_TOS_INT_r22 },
+ { 3, 3, _GUARD_TOS_INT_r33 },
+ },
+ },
+ [_GUARD_NOS_OVERFLOWED] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_OVERFLOWED_r02 },
+ { 2, 1, _GUARD_NOS_OVERFLOWED_r12 },
+ { 2, 2, _GUARD_NOS_OVERFLOWED_r22 },
+ { 3, 3, _GUARD_NOS_OVERFLOWED_r33 },
+ },
+ },
+ [_GUARD_TOS_OVERFLOWED] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_OVERFLOWED_r01 },
+ { 1, 1, _GUARD_TOS_OVERFLOWED_r11 },
+ { 2, 2, _GUARD_TOS_OVERFLOWED_r22 },
+ { 3, 3, _GUARD_TOS_OVERFLOWED_r33 },
+ },
+ },
+ [_BINARY_OP_MULTIPLY_INT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_MULTIPLY_INT_r01 },
+ { 1, 1, _BINARY_OP_MULTIPLY_INT_r11 },
+ { 1, 2, _BINARY_OP_MULTIPLY_INT_r21 },
+ { 2, 3, _BINARY_OP_MULTIPLY_INT_r32 },
+ },
+ },
+ [_BINARY_OP_ADD_INT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_ADD_INT_r01 },
+ { 1, 1, _BINARY_OP_ADD_INT_r11 },
+ { 1, 2, _BINARY_OP_ADD_INT_r21 },
+ { 2, 3, _BINARY_OP_ADD_INT_r32 },
+ },
+ },
+ [_BINARY_OP_SUBTRACT_INT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_SUBTRACT_INT_r01 },
+ { 1, 1, _BINARY_OP_SUBTRACT_INT_r11 },
+ { 1, 2, _BINARY_OP_SUBTRACT_INT_r21 },
+ { 2, 3, _BINARY_OP_SUBTRACT_INT_r32 },
+ },
+ },
+ [_GUARD_NOS_FLOAT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_FLOAT_r02 },
+ { 2, 1, _GUARD_NOS_FLOAT_r12 },
+ { 2, 2, _GUARD_NOS_FLOAT_r22 },
+ { 3, 3, _GUARD_NOS_FLOAT_r33 },
+ },
+ },
+ [_GUARD_TOS_FLOAT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_FLOAT_r01 },
+ { 1, 1, _GUARD_TOS_FLOAT_r11 },
+ { 2, 2, _GUARD_TOS_FLOAT_r22 },
+ { 3, 3, _GUARD_TOS_FLOAT_r33 },
+ },
+ },
+ [_BINARY_OP_MULTIPLY_FLOAT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_MULTIPLY_FLOAT_r01 },
+ { 1, 1, _BINARY_OP_MULTIPLY_FLOAT_r11 },
+ { 1, 2, _BINARY_OP_MULTIPLY_FLOAT_r21 },
+ { 2, 3, _BINARY_OP_MULTIPLY_FLOAT_r32 },
+ },
+ },
+ [_BINARY_OP_ADD_FLOAT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_ADD_FLOAT_r01 },
+ { 1, 1, _BINARY_OP_ADD_FLOAT_r11 },
+ { 1, 2, _BINARY_OP_ADD_FLOAT_r21 },
+ { 2, 3, _BINARY_OP_ADD_FLOAT_r32 },
+ },
+ },
+ [_BINARY_OP_SUBTRACT_FLOAT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_SUBTRACT_FLOAT_r01 },
+ { 1, 1, _BINARY_OP_SUBTRACT_FLOAT_r11 },
+ { 1, 2, _BINARY_OP_SUBTRACT_FLOAT_r21 },
+ { 2, 3, _BINARY_OP_SUBTRACT_FLOAT_r32 },
+ },
+ },
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r01 },
+ { 1, 1, _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r11 },
+ { 1, 2, _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r21 },
+ { 2, 3, _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r32 },
+ },
+ },
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r01 },
+ { 1, 1, _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r11 },
+ { 1, 2, _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r21 },
+ { 2, 3, _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r32 },
+ },
+ },
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r01 },
+ { 1, 1, _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r11 },
+ { 1, 2, _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r21 },
+ { 2, 3, _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r32 },
+ },
+ },
+ [_BINARY_OP_ADD_UNICODE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_ADD_UNICODE_r01 },
+ { 1, 1, _BINARY_OP_ADD_UNICODE_r11 },
+ { 1, 2, _BINARY_OP_ADD_UNICODE_r21 },
+ { 2, 3, _BINARY_OP_ADD_UNICODE_r32 },
+ },
+ },
+ [_BINARY_OP_INPLACE_ADD_UNICODE] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 0, _BINARY_OP_INPLACE_ADD_UNICODE_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_BINARY_OP_EXTEND] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 2, 0, _GUARD_BINARY_OP_EXTEND_r22 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BINARY_OP_EXTEND] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _BINARY_OP_EXTEND_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BINARY_SLICE] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _BINARY_SLICE_r31 },
+ },
+ },
+ [_STORE_SLICE] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 0, _STORE_SLICE_r30 },
+ },
+ },
+ [_BINARY_OP_SUBSCR_LIST_INT] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _BINARY_OP_SUBSCR_LIST_INT_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BINARY_OP_SUBSCR_LIST_SLICE] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _BINARY_OP_SUBSCR_LIST_SLICE_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BINARY_OP_SUBSCR_STR_INT] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 2, _BINARY_OP_SUBSCR_STR_INT_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_NOS_TUPLE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_TUPLE_r02 },
+ { 2, 1, _GUARD_NOS_TUPLE_r12 },
+ { 2, 2, _GUARD_NOS_TUPLE_r22 },
+ { 3, 3, _GUARD_NOS_TUPLE_r33 },
+ },
+ },
+ [_GUARD_TOS_TUPLE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_TUPLE_r01 },
+ { 1, 1, _GUARD_TOS_TUPLE_r11 },
+ { 2, 2, _GUARD_TOS_TUPLE_r22 },
+ { 3, 3, _GUARD_TOS_TUPLE_r33 },
+ },
+ },
+ [_BINARY_OP_SUBSCR_TUPLE_INT] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 2, _BINARY_OP_SUBSCR_TUPLE_INT_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_NOS_DICT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_DICT_r02 },
+ { 2, 1, _GUARD_NOS_DICT_r12 },
+ { 2, 2, _GUARD_NOS_DICT_r22 },
+ { 3, 3, _GUARD_NOS_DICT_r33 },
+ },
+ },
+ [_GUARD_TOS_DICT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_DICT_r01 },
+ { 1, 1, _GUARD_TOS_DICT_r11 },
+ { 2, 2, _GUARD_TOS_DICT_r22 },
+ { 3, 3, _GUARD_TOS_DICT_r33 },
+ },
+ },
+ [_BINARY_OP_SUBSCR_DICT] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _BINARY_OP_SUBSCR_DICT_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BINARY_OP_SUBSCR_CHECK_FUNC] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 3, 2, _BINARY_OP_SUBSCR_CHECK_FUNC_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BINARY_OP_SUBSCR_INIT_CALL] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _BINARY_OP_SUBSCR_INIT_CALL_r01 },
+ { 1, 1, _BINARY_OP_SUBSCR_INIT_CALL_r11 },
+ { 1, 2, _BINARY_OP_SUBSCR_INIT_CALL_r21 },
+ { 1, 3, _BINARY_OP_SUBSCR_INIT_CALL_r31 },
+ },
+ },
+ [_LIST_APPEND] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _LIST_APPEND_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_SET_ADD] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _SET_ADD_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_SUBSCR] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 0, _STORE_SUBSCR_r30 },
+ },
+ },
+ [_STORE_SUBSCR_LIST_INT] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 3, _STORE_SUBSCR_LIST_INT_r30 },
+ },
+ },
+ [_STORE_SUBSCR_DICT] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 0, _STORE_SUBSCR_DICT_r30 },
+ },
+ },
+ [_DELETE_SUBSCR] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 0, _DELETE_SUBSCR_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_INTRINSIC_1] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _CALL_INTRINSIC_1_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_INTRINSIC_2] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _CALL_INTRINSIC_2_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_RETURN_VALUE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _RETURN_VALUE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GET_AITER] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _GET_AITER_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GET_ANEXT] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 2, 0, _GET_ANEXT_r12 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GET_AWAITABLE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _GET_AWAITABLE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_SEND_GEN_FRAME] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 2, 2, _SEND_GEN_FRAME_r22 },
+ { -1, -1, -1 },
+ },
+ },
+ [_YIELD_VALUE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _YIELD_VALUE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_EXCEPT] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _POP_EXCEPT_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_COMMON_CONSTANT] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_COMMON_CONSTANT_r01 },
+ { 2, 1, _LOAD_COMMON_CONSTANT_r12 },
+ { 3, 2, _LOAD_COMMON_CONSTANT_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_BUILD_CLASS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _LOAD_BUILD_CLASS_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_NAME] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _STORE_NAME_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_DELETE_NAME] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _DELETE_NAME_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_UNPACK_SEQUENCE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _UNPACK_SEQUENCE_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_UNPACK_SEQUENCE_TWO_TUPLE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 2, 1, _UNPACK_SEQUENCE_TWO_TUPLE_r12 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_UNPACK_SEQUENCE_TUPLE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _UNPACK_SEQUENCE_TUPLE_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_UNPACK_SEQUENCE_LIST] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _UNPACK_SEQUENCE_LIST_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_UNPACK_EX] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _UNPACK_EX_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_ATTR] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 0, _STORE_ATTR_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_DELETE_ATTR] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _DELETE_ATTR_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_GLOBAL] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _STORE_GLOBAL_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_DELETE_GLOBAL] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _DELETE_GLOBAL_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_LOCALS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _LOAD_LOCALS_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_NAME] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _LOAD_NAME_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_GLOBAL] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _LOAD_GLOBAL_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_PUSH_NULL_CONDITIONAL] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _PUSH_NULL_CONDITIONAL_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_GLOBALS_VERSION] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _GUARD_GLOBALS_VERSION_r00 },
+ { 1, 1, _GUARD_GLOBALS_VERSION_r11 },
+ { 2, 2, _GUARD_GLOBALS_VERSION_r22 },
+ { 3, 3, _GUARD_GLOBALS_VERSION_r33 },
+ },
+ },
+ [_LOAD_GLOBAL_MODULE] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _LOAD_GLOBAL_MODULE_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_GLOBAL_BUILTINS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _LOAD_GLOBAL_BUILTINS_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_DELETE_FAST] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _DELETE_FAST_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MAKE_CELL] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _MAKE_CELL_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_DELETE_DEREF] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _DELETE_DEREF_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_FROM_DICT_OR_DEREF] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _LOAD_FROM_DICT_OR_DEREF_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_DEREF] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _LOAD_DEREF_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_DEREF] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _STORE_DEREF_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_COPY_FREE_VARS] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _COPY_FREE_VARS_r00 },
+ { 1, 1, _COPY_FREE_VARS_r11 },
+ { 2, 2, _COPY_FREE_VARS_r22 },
+ { 3, 3, _COPY_FREE_VARS_r33 },
+ },
+ },
+ [_BUILD_STRING] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _BUILD_STRING_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BUILD_INTERPOLATION] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _BUILD_INTERPOLATION_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BUILD_TEMPLATE] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _BUILD_TEMPLATE_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BUILD_TUPLE] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _BUILD_TUPLE_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BUILD_LIST] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _BUILD_LIST_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LIST_EXTEND] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _LIST_EXTEND_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_SET_UPDATE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _SET_UPDATE_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BUILD_SET] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _BUILD_SET_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BUILD_MAP] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _BUILD_MAP_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_SETUP_ANNOTATIONS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _SETUP_ANNOTATIONS_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_DICT_UPDATE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _DICT_UPDATE_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_DICT_MERGE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _DICT_MERGE_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MAP_ADD] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 0, _MAP_ADD_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_SUPER_ATTR_ATTR] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _LOAD_SUPER_ATTR_ATTR_r31 },
+ },
+ },
+ [_LOAD_SUPER_ATTR_METHOD] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 2, 0, _LOAD_SUPER_ATTR_METHOD_r32 },
+ },
+ },
+ [_LOAD_ATTR] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _LOAD_ATTR_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_TYPE_VERSION] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TYPE_VERSION_r01 },
+ { 1, 1, _GUARD_TYPE_VERSION_r11 },
+ { 2, 2, _GUARD_TYPE_VERSION_r22 },
+ { 3, 3, _GUARD_TYPE_VERSION_r33 },
+ },
+ },
+ [_GUARD_TYPE_VERSION_AND_LOCK] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TYPE_VERSION_AND_LOCK_r01 },
+ { 1, 1, _GUARD_TYPE_VERSION_AND_LOCK_r11 },
+ { 2, 2, _GUARD_TYPE_VERSION_AND_LOCK_r22 },
+ { 3, 3, _GUARD_TYPE_VERSION_AND_LOCK_r33 },
+ },
+ },
+ [_CHECK_MANAGED_OBJECT_HAS_VALUES] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _CHECK_MANAGED_OBJECT_HAS_VALUES_r01 },
+ { 1, 1, _CHECK_MANAGED_OBJECT_HAS_VALUES_r11 },
+ { 2, 2, _CHECK_MANAGED_OBJECT_HAS_VALUES_r22 },
+ { 3, 3, _CHECK_MANAGED_OBJECT_HAS_VALUES_r33 },
+ },
+ },
+ [_LOAD_ATTR_INSTANCE_VALUE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _LOAD_ATTR_INSTANCE_VALUE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_ATTR_MODULE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _LOAD_ATTR_MODULE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_ATTR_WITH_HINT] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _LOAD_ATTR_WITH_HINT_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_ATTR_SLOT] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _LOAD_ATTR_SLOT_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_ATTR_CLASS] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _CHECK_ATTR_CLASS_r01 },
+ { 1, 1, _CHECK_ATTR_CLASS_r11 },
+ { 2, 2, _CHECK_ATTR_CLASS_r22 },
+ { 3, 3, _CHECK_ATTR_CLASS_r33 },
+ },
+ },
+ [_LOAD_ATTR_CLASS] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _LOAD_ATTR_CLASS_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_ATTR_PROPERTY_FRAME] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _LOAD_ATTR_PROPERTY_FRAME_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_DORV_NO_DICT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_DORV_NO_DICT_r01 },
+ { 1, 1, _GUARD_DORV_NO_DICT_r11 },
+ { 2, 2, _GUARD_DORV_NO_DICT_r22 },
+ { 3, 3, _GUARD_DORV_NO_DICT_r33 },
+ },
+ },
+ [_STORE_ATTR_INSTANCE_VALUE] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 2, _STORE_ATTR_INSTANCE_VALUE_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_ATTR_WITH_HINT] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 0, _STORE_ATTR_WITH_HINT_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_STORE_ATTR_SLOT] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 2, _STORE_ATTR_SLOT_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_COMPARE_OP] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _COMPARE_OP_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_COMPARE_OP_FLOAT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _COMPARE_OP_FLOAT_r01 },
+ { 1, 1, _COMPARE_OP_FLOAT_r11 },
+ { 1, 2, _COMPARE_OP_FLOAT_r21 },
+ { 2, 3, _COMPARE_OP_FLOAT_r32 },
+ },
+ },
+ [_COMPARE_OP_INT] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 2, _COMPARE_OP_INT_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_COMPARE_OP_STR] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 2, _COMPARE_OP_STR_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_IS_OP] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 2, _IS_OP_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CONTAINS_OP] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _CONTAINS_OP_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_TOS_ANY_SET] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_TOS_ANY_SET_r01 },
+ { 1, 1, _GUARD_TOS_ANY_SET_r11 },
+ { 2, 2, _GUARD_TOS_ANY_SET_r22 },
+ { 3, 3, _GUARD_TOS_ANY_SET_r33 },
+ },
+ },
+ [_CONTAINS_OP_SET] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _CONTAINS_OP_SET_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CONTAINS_OP_DICT] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _CONTAINS_OP_DICT_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_EG_MATCH] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 2, 0, _CHECK_EG_MATCH_r22 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_EXC_MATCH] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 2, 0, _CHECK_EXC_MATCH_r22 },
+ { -1, -1, -1 },
+ },
+ },
+ [_IMPORT_NAME] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _IMPORT_NAME_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_IMPORT_FROM] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 2, 0, _IMPORT_FROM_r12 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_IS_NONE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _IS_NONE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GET_LEN] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 2, 0, _GET_LEN_r12 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MATCH_CLASS] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _MATCH_CLASS_r31 },
+ },
+ },
+ [_MATCH_MAPPING] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _MATCH_MAPPING_r02 },
+ { 2, 1, _MATCH_MAPPING_r12 },
+ { 3, 2, _MATCH_MAPPING_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MATCH_SEQUENCE] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _MATCH_SEQUENCE_r02 },
+ { 2, 1, _MATCH_SEQUENCE_r12 },
+ { 3, 2, _MATCH_SEQUENCE_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MATCH_KEYS] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 3, 0, _MATCH_KEYS_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GET_ITER] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 2, 0, _GET_ITER_r12 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GET_YIELD_FROM_ITER] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _GET_YIELD_FROM_ITER_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_FOR_ITER_TIER_TWO] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 3, 0, _FOR_ITER_TIER_TWO_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_ITER_CHECK_LIST] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _ITER_CHECK_LIST_r02 },
+ { 2, 1, _ITER_CHECK_LIST_r12 },
+ { 2, 2, _ITER_CHECK_LIST_r22 },
+ { 3, 3, _ITER_CHECK_LIST_r33 },
+ },
+ },
+ [_GUARD_NOT_EXHAUSTED_LIST] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOT_EXHAUSTED_LIST_r02 },
+ { 2, 1, _GUARD_NOT_EXHAUSTED_LIST_r12 },
+ { 2, 2, _GUARD_NOT_EXHAUSTED_LIST_r22 },
+ { 3, 3, _GUARD_NOT_EXHAUSTED_LIST_r33 },
+ },
+ },
+ [_ITER_NEXT_LIST_TIER_TWO] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 3, 0, _ITER_NEXT_LIST_TIER_TWO_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_ITER_CHECK_TUPLE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _ITER_CHECK_TUPLE_r02 },
+ { 2, 1, _ITER_CHECK_TUPLE_r12 },
+ { 2, 2, _ITER_CHECK_TUPLE_r22 },
+ { 3, 3, _ITER_CHECK_TUPLE_r33 },
+ },
+ },
+ [_GUARD_NOT_EXHAUSTED_TUPLE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOT_EXHAUSTED_TUPLE_r02 },
+ { 2, 1, _GUARD_NOT_EXHAUSTED_TUPLE_r12 },
+ { 2, 2, _GUARD_NOT_EXHAUSTED_TUPLE_r22 },
+ { 3, 3, _GUARD_NOT_EXHAUSTED_TUPLE_r33 },
+ },
+ },
+ [_ITER_NEXT_TUPLE] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 3, 0, _ITER_NEXT_TUPLE_r03 },
+ { 3, 1, _ITER_NEXT_TUPLE_r13 },
+ { 3, 2, _ITER_NEXT_TUPLE_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_ITER_CHECK_RANGE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _ITER_CHECK_RANGE_r02 },
+ { 2, 1, _ITER_CHECK_RANGE_r12 },
+ { 2, 2, _ITER_CHECK_RANGE_r22 },
+ { 3, 3, _ITER_CHECK_RANGE_r33 },
+ },
+ },
+ [_GUARD_NOT_EXHAUSTED_RANGE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOT_EXHAUSTED_RANGE_r02 },
+ { 2, 1, _GUARD_NOT_EXHAUSTED_RANGE_r12 },
+ { 2, 2, _GUARD_NOT_EXHAUSTED_RANGE_r22 },
+ { 3, 3, _GUARD_NOT_EXHAUSTED_RANGE_r33 },
+ },
+ },
+ [_ITER_NEXT_RANGE] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 3, 0, _ITER_NEXT_RANGE_r03 },
+ { 3, 1, _ITER_NEXT_RANGE_r13 },
+ { 3, 2, _ITER_NEXT_RANGE_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_FOR_ITER_GEN_FRAME] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 3, 2, _FOR_ITER_GEN_FRAME_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_INSERT_NULL] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 1, _INSERT_NULL_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_SPECIAL] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _LOAD_SPECIAL_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_WITH_EXCEPT_START] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 3, 0, _WITH_EXCEPT_START_r33 },
+ },
+ },
+ [_PUSH_EXC_INFO] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _PUSH_EXC_INFO_r02 },
+ { 2, 1, _PUSH_EXC_INFO_r12 },
+ { 3, 2, _PUSH_EXC_INFO_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01 },
+ { 1, 1, _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11 },
+ { 2, 2, _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22 },
+ { 3, 3, _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33 },
+ },
+ },
+ [_GUARD_KEYS_VERSION] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _GUARD_KEYS_VERSION_r01 },
+ { 1, 1, _GUARD_KEYS_VERSION_r11 },
+ { 2, 2, _GUARD_KEYS_VERSION_r22 },
+ { 3, 3, _GUARD_KEYS_VERSION_r33 },
+ },
+ },
+ [_LOAD_ATTR_METHOD_WITH_VALUES] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _LOAD_ATTR_METHOD_WITH_VALUES_r02 },
+ { 2, 1, _LOAD_ATTR_METHOD_WITH_VALUES_r12 },
+ { 3, 2, _LOAD_ATTR_METHOD_WITH_VALUES_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_ATTR_METHOD_NO_DICT] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _LOAD_ATTR_METHOD_NO_DICT_r02 },
+ { 2, 1, _LOAD_ATTR_METHOD_NO_DICT_r12 },
+ { 3, 2, _LOAD_ATTR_METHOD_NO_DICT_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_ATTR_METHOD_LAZY_DICT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _CHECK_ATTR_METHOD_LAZY_DICT_r01 },
+ { 1, 1, _CHECK_ATTR_METHOD_LAZY_DICT_r11 },
+ { 2, 2, _CHECK_ATTR_METHOD_LAZY_DICT_r22 },
+ { 3, 3, _CHECK_ATTR_METHOD_LAZY_DICT_r33 },
+ },
+ },
+ [_LOAD_ATTR_METHOD_LAZY_DICT] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _LOAD_ATTR_METHOD_LAZY_DICT_r02 },
+ { 2, 1, _LOAD_ATTR_METHOD_LAZY_DICT_r12 },
+ { 3, 2, _LOAD_ATTR_METHOD_LAZY_DICT_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MAYBE_EXPAND_METHOD] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _MAYBE_EXPAND_METHOD_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_PY_FRAME_GENERAL] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _PY_FRAME_GENERAL_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_FUNCTION_VERSION] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_FUNCTION_VERSION_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_FUNCTION_VERSION_INLINE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _CHECK_FUNCTION_VERSION_INLINE_r00 },
+ { 1, 1, _CHECK_FUNCTION_VERSION_INLINE_r11 },
+ { 2, 2, _CHECK_FUNCTION_VERSION_INLINE_r22 },
+ { 3, 3, _CHECK_FUNCTION_VERSION_INLINE_r33 },
+ },
+ },
+ [_CHECK_METHOD_VERSION] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_METHOD_VERSION_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_EXPAND_METHOD] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _EXPAND_METHOD_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_IS_NOT_PY_CALLABLE] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_IS_NOT_PY_CALLABLE_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_NON_PY_GENERAL] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_NON_PY_GENERAL_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_PEP_523] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _CHECK_PEP_523_r00 },
+ { 1, 1, _CHECK_PEP_523_r11 },
+ { 2, 2, _CHECK_PEP_523_r22 },
+ { 3, 3, _CHECK_PEP_523_r33 },
+ },
+ },
+ [_CHECK_FUNCTION_EXACT_ARGS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_FUNCTION_EXACT_ARGS_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_STACK_SPACE] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_STACK_SPACE_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_RECURSION_REMAINING] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _CHECK_RECURSION_REMAINING_r00 },
+ { 1, 1, _CHECK_RECURSION_REMAINING_r11 },
+ { 2, 2, _CHECK_RECURSION_REMAINING_r22 },
+ { 3, 3, _CHECK_RECURSION_REMAINING_r33 },
+ },
+ },
+ [_INIT_CALL_PY_EXACT_ARGS_0] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _INIT_CALL_PY_EXACT_ARGS_0_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_INIT_CALL_PY_EXACT_ARGS_1] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _INIT_CALL_PY_EXACT_ARGS_1_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_INIT_CALL_PY_EXACT_ARGS_2] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _INIT_CALL_PY_EXACT_ARGS_2_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_INIT_CALL_PY_EXACT_ARGS_3] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _INIT_CALL_PY_EXACT_ARGS_3_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_INIT_CALL_PY_EXACT_ARGS_4] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _INIT_CALL_PY_EXACT_ARGS_4_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_INIT_CALL_PY_EXACT_ARGS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _INIT_CALL_PY_EXACT_ARGS_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_PUSH_FRAME] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _PUSH_FRAME_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_NOS_NULL] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_NULL_r02 },
+ { 2, 1, _GUARD_NOS_NULL_r12 },
+ { 2, 2, _GUARD_NOS_NULL_r22 },
+ { 3, 3, _GUARD_NOS_NULL_r33 },
+ },
+ },
+ [_GUARD_NOS_NOT_NULL] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _GUARD_NOS_NOT_NULL_r02 },
+ { 2, 1, _GUARD_NOS_NOT_NULL_r12 },
+ { 2, 2, _GUARD_NOS_NOT_NULL_r22 },
+ { 3, 3, _GUARD_NOS_NOT_NULL_r33 },
+ },
+ },
+ [_GUARD_THIRD_NULL] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 3, 0, _GUARD_THIRD_NULL_r03 },
+ { 3, 1, _GUARD_THIRD_NULL_r13 },
+ { 3, 2, _GUARD_THIRD_NULL_r23 },
+ { 3, 3, _GUARD_THIRD_NULL_r33 },
+ },
+ },
+ [_GUARD_CALLABLE_TYPE_1] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 3, 0, _GUARD_CALLABLE_TYPE_1_r03 },
+ { 3, 1, _GUARD_CALLABLE_TYPE_1_r13 },
+ { 3, 2, _GUARD_CALLABLE_TYPE_1_r23 },
+ { 3, 3, _GUARD_CALLABLE_TYPE_1_r33 },
+ },
+ },
+ [_CALL_TYPE_1] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 3, _CALL_TYPE_1_r31 },
+ },
+ },
+ [_GUARD_CALLABLE_STR_1] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 3, 0, _GUARD_CALLABLE_STR_1_r03 },
+ { 3, 1, _GUARD_CALLABLE_STR_1_r13 },
+ { 3, 2, _GUARD_CALLABLE_STR_1_r23 },
+ { 3, 3, _GUARD_CALLABLE_STR_1_r33 },
+ },
+ },
+ [_CALL_STR_1] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _CALL_STR_1_r31 },
+ },
+ },
+ [_GUARD_CALLABLE_TUPLE_1] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 3, 0, _GUARD_CALLABLE_TUPLE_1_r03 },
+ { 3, 1, _GUARD_CALLABLE_TUPLE_1_r13 },
+ { 3, 2, _GUARD_CALLABLE_TUPLE_1_r23 },
+ { 3, 3, _GUARD_CALLABLE_TUPLE_1_r33 },
+ },
+ },
+ [_CALL_TUPLE_1] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _CALL_TUPLE_1_r31 },
+ },
+ },
+ [_CHECK_AND_ALLOCATE_OBJECT] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _CHECK_AND_ALLOCATE_OBJECT_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CREATE_INIT_FRAME] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CREATE_INIT_FRAME_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_EXIT_INIT_CHECK] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _EXIT_INIT_CHECK_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_BUILTIN_CLASS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_BUILTIN_CLASS_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_BUILTIN_O] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_BUILTIN_O_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_BUILTIN_FAST] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_BUILTIN_FAST_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_BUILTIN_FAST_WITH_KEYWORDS_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_CALLABLE_LEN] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 3, 0, _GUARD_CALLABLE_LEN_r03 },
+ { 3, 1, _GUARD_CALLABLE_LEN_r13 },
+ { 3, 2, _GUARD_CALLABLE_LEN_r23 },
+ { 3, 3, _GUARD_CALLABLE_LEN_r33 },
+ },
+ },
+ [_CALL_LEN] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _CALL_LEN_r31 },
+ },
+ },
+ [_GUARD_CALLABLE_ISINSTANCE] = {
+ .best = { 0, 1, 2, 3 },
+ .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 },
+ },
+ },
+ [_CALL_ISINSTANCE] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _CALL_ISINSTANCE_r31 },
+ },
+ },
+ [_GUARD_CALLABLE_LIST_APPEND] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 3, 0, _GUARD_CALLABLE_LIST_APPEND_r03 },
+ { 3, 1, _GUARD_CALLABLE_LIST_APPEND_r13 },
+ { 3, 2, _GUARD_CALLABLE_LIST_APPEND_r23 },
+ { 3, 3, _GUARD_CALLABLE_LIST_APPEND_r33 },
+ },
+ },
+ [_CALL_LIST_APPEND] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 3, _CALL_LIST_APPEND_r30 },
+ },
+ },
+ [_CALL_METHOD_DESCRIPTOR_O] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_METHOD_DESCRIPTOR_O_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_METHOD_DESCRIPTOR_NOARGS] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_METHOD_DESCRIPTOR_NOARGS_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_METHOD_DESCRIPTOR_FAST] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _CALL_METHOD_DESCRIPTOR_FAST_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MAYBE_EXPAND_METHOD_KW] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _MAYBE_EXPAND_METHOD_KW_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_PY_FRAME_KW] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _PY_FRAME_KW_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_FUNCTION_VERSION_KW] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _CHECK_FUNCTION_VERSION_KW_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_METHOD_VERSION_KW] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _CHECK_METHOD_VERSION_KW_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_EXPAND_METHOD_KW] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _EXPAND_METHOD_KW_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CHECK_IS_NOT_PY_CALLABLE_KW] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _CHECK_IS_NOT_PY_CALLABLE_KW_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CALL_KW_NON_PY] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _CALL_KW_NON_PY_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MAKE_CALLARGS_A_TUPLE] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 3, 0, _MAKE_CALLARGS_A_TUPLE_r33 },
+ },
+ },
+ [_MAKE_FUNCTION] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _MAKE_FUNCTION_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_SET_FUNCTION_ATTRIBUTE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 1, 0, _SET_FUNCTION_ATTRIBUTE_r01 },
+ { 1, 1, _SET_FUNCTION_ATTRIBUTE_r11 },
+ { 1, 2, _SET_FUNCTION_ATTRIBUTE_r21 },
+ { 2, 3, _SET_FUNCTION_ATTRIBUTE_r32 },
+ },
+ },
+ [_RETURN_GENERATOR] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _RETURN_GENERATOR_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BUILD_SLICE] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _BUILD_SLICE_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_CONVERT_VALUE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _CONVERT_VALUE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_FORMAT_SIMPLE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 0, _FORMAT_SIMPLE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_FORMAT_WITH_SPEC] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _FORMAT_WITH_SPEC_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_COPY_1] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _COPY_1_r02 },
+ { 2, 1, _COPY_1_r12 },
+ { 3, 2, _COPY_1_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_COPY_2] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 3, 0, _COPY_2_r03 },
+ { 3, 1, _COPY_2_r13 },
+ { 3, 2, _COPY_2_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_COPY_3] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 3, 0, _COPY_3_r03 },
+ { 3, 1, _COPY_3_r13 },
+ { 3, 2, _COPY_3_r23 },
+ { 3, 3, _COPY_3_r33 },
+ },
+ },
+ [_COPY] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 1, 0, _COPY_r01 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_BINARY_OP] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 0, _BINARY_OP_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_SWAP_2] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 2, 0, _SWAP_2_r02 },
+ { 2, 1, _SWAP_2_r12 },
+ { 2, 2, _SWAP_2_r22 },
+ { 3, 3, _SWAP_2_r33 },
+ },
+ },
+ [_SWAP_3] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 3, 0, _SWAP_3_r03 },
+ { 3, 1, _SWAP_3_r13 },
+ { 3, 2, _SWAP_3_r23 },
+ { 3, 3, _SWAP_3_r33 },
+ },
+ },
+ [_SWAP] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _SWAP_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_IS_TRUE_POP] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _GUARD_IS_TRUE_POP_r00 },
+ { 0, 0, _GUARD_IS_TRUE_POP_r10 },
+ { 1, 1, _GUARD_IS_TRUE_POP_r21 },
+ { 2, 2, _GUARD_IS_TRUE_POP_r32 },
+ },
+ },
+ [_GUARD_IS_FALSE_POP] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _GUARD_IS_FALSE_POP_r00 },
+ { 0, 0, _GUARD_IS_FALSE_POP_r10 },
+ { 1, 1, _GUARD_IS_FALSE_POP_r21 },
+ { 2, 2, _GUARD_IS_FALSE_POP_r32 },
+ },
+ },
+ [_GUARD_IS_NONE_POP] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _GUARD_IS_NONE_POP_r00 },
+ { 0, 0, _GUARD_IS_NONE_POP_r10 },
+ { 1, 1, _GUARD_IS_NONE_POP_r21 },
+ { 2, 2, _GUARD_IS_NONE_POP_r32 },
+ },
+ },
+ [_GUARD_IS_NOT_NONE_POP] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 0, 0, _GUARD_IS_NOT_NONE_POP_r10 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_JUMP_TO_TOP] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _JUMP_TO_TOP_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_SET_IP] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _SET_IP_r00 },
+ { 1, 1, _SET_IP_r11 },
+ { 2, 2, _SET_IP_r22 },
+ { 3, 3, _SET_IP_r33 },
+ },
+ },
+ [_CHECK_STACK_SPACE_OPERAND] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _CHECK_STACK_SPACE_OPERAND_r00 },
+ { 1, 1, _CHECK_STACK_SPACE_OPERAND_r11 },
+ { 2, 2, _CHECK_STACK_SPACE_OPERAND_r22 },
+ { 3, 3, _CHECK_STACK_SPACE_OPERAND_r33 },
+ },
+ },
+ [_SAVE_RETURN_OFFSET] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _SAVE_RETURN_OFFSET_r00 },
+ { 1, 1, _SAVE_RETURN_OFFSET_r11 },
+ { 2, 2, _SAVE_RETURN_OFFSET_r22 },
+ { 3, 3, _SAVE_RETURN_OFFSET_r33 },
+ },
+ },
+ [_EXIT_TRACE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _EXIT_TRACE_r00 },
+ { 0, 0, _EXIT_TRACE_r10 },
+ { 0, 0, _EXIT_TRACE_r20 },
+ { 0, 0, _EXIT_TRACE_r30 },
+ },
+ },
+ [_DYNAMIC_EXIT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _DYNAMIC_EXIT_r00 },
+ { 0, 0, _DYNAMIC_EXIT_r10 },
+ { 0, 0, _DYNAMIC_EXIT_r20 },
+ { 0, 0, _DYNAMIC_EXIT_r30 },
+ },
+ },
+ [_CHECK_VALIDITY] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _CHECK_VALIDITY_r00 },
+ { 1, 1, _CHECK_VALIDITY_r11 },
+ { 2, 2, _CHECK_VALIDITY_r22 },
+ { 3, 3, _CHECK_VALIDITY_r33 },
+ },
+ },
+ [_LOAD_CONST_INLINE] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_CONST_INLINE_r01 },
+ { 2, 1, _LOAD_CONST_INLINE_r12 },
+ { 3, 2, _LOAD_CONST_INLINE_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_TOP_LOAD_CONST_INLINE] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _POP_TOP_LOAD_CONST_INLINE_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_CONST_INLINE_BORROW] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 1, 0, _LOAD_CONST_INLINE_BORROW_r01 },
+ { 2, 1, _LOAD_CONST_INLINE_BORROW_r12 },
+ { 3, 2, _LOAD_CONST_INLINE_BORROW_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_CALL] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 2, _POP_CALL_r20 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_CALL_ONE] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 3, _POP_CALL_ONE_r30 },
+ },
+ },
+ [_POP_CALL_TWO] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 0, 3, _POP_CALL_TWO_r30 },
+ },
+ },
+ [_POP_TOP_LOAD_CONST_INLINE_BORROW] = {
+ .best = { 1, 1, 1, 1 },
+ .entries = {
+ { -1, -1, -1 },
+ { 1, 1, _POP_TOP_LOAD_CONST_INLINE_BORROW_r11 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_TWO_LOAD_CONST_INLINE_BORROW] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 2, _POP_TWO_LOAD_CONST_INLINE_BORROW_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_CALL_LOAD_CONST_INLINE_BORROW] = {
+ .best = { 2, 2, 2, 2 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 2, _POP_CALL_LOAD_CONST_INLINE_BORROW_r21 },
+ { -1, -1, -1 },
+ },
+ },
+ [_POP_CALL_ONE_LOAD_CONST_INLINE_BORROW] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 3, _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31 },
+ },
+ },
+ [_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW] = {
+ .best = { 3, 3, 3, 3 },
+ .entries = {
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { 1, 3, _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31 },
+ },
+ },
+ [_LOAD_CONST_UNDER_INLINE] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _LOAD_CONST_UNDER_INLINE_r02 },
+ { 2, 1, _LOAD_CONST_UNDER_INLINE_r12 },
+ { 3, 2, _LOAD_CONST_UNDER_INLINE_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_LOAD_CONST_UNDER_INLINE_BORROW] = {
+ .best = { 0, 1, 2, 2 },
+ .entries = {
+ { 2, 0, _LOAD_CONST_UNDER_INLINE_BORROW_r02 },
+ { 2, 1, _LOAD_CONST_UNDER_INLINE_BORROW_r12 },
+ { 3, 2, _LOAD_CONST_UNDER_INLINE_BORROW_r23 },
+ { -1, -1, -1 },
+ },
+ },
+ [_START_EXECUTOR] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _START_EXECUTOR_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_MAKE_WARM] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _MAKE_WARM_r00 },
+ { 1, 1, _MAKE_WARM_r11 },
+ { 2, 2, _MAKE_WARM_r22 },
+ { 3, 3, _MAKE_WARM_r33 },
+ },
+ },
+ [_FATAL_ERROR] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _FATAL_ERROR_r00 },
+ { 1, 1, _FATAL_ERROR_r11 },
+ { 2, 2, _FATAL_ERROR_r22 },
+ { 3, 3, _FATAL_ERROR_r33 },
+ },
+ },
+ [_DEOPT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _DEOPT_r00 },
+ { 0, 0, _DEOPT_r10 },
+ { 0, 0, _DEOPT_r20 },
+ { 0, 0, _DEOPT_r30 },
+ },
+ },
+ [_HANDLE_PENDING_AND_DEOPT] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _HANDLE_PENDING_AND_DEOPT_r00 },
+ { 0, 0, _HANDLE_PENDING_AND_DEOPT_r10 },
+ { 0, 0, _HANDLE_PENDING_AND_DEOPT_r20 },
+ { 0, 0, _HANDLE_PENDING_AND_DEOPT_r30 },
+ },
+ },
+ [_ERROR_POP_N] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _ERROR_POP_N_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_TIER2_RESUME_CHECK] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _TIER2_RESUME_CHECK_r00 },
+ { 1, 1, _TIER2_RESUME_CHECK_r11 },
+ { 2, 2, _TIER2_RESUME_CHECK_r22 },
+ { 3, 3, _TIER2_RESUME_CHECK_r33 },
+ },
+ },
+ [_COLD_EXIT] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _COLD_EXIT_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_COLD_DYNAMIC_EXIT] = {
+ .best = { 0, 0, 0, 0 },
+ .entries = {
+ { 0, 0, _COLD_DYNAMIC_EXIT_r00 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ { -1, -1, -1 },
+ },
+ },
+ [_GUARD_IP__PUSH_FRAME] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _GUARD_IP__PUSH_FRAME_r00 },
+ { 1, 1, _GUARD_IP__PUSH_FRAME_r11 },
+ { 2, 2, _GUARD_IP__PUSH_FRAME_r22 },
+ { 3, 3, _GUARD_IP__PUSH_FRAME_r33 },
+ },
+ },
+ [_GUARD_IP_YIELD_VALUE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _GUARD_IP_YIELD_VALUE_r00 },
+ { 1, 1, _GUARD_IP_YIELD_VALUE_r11 },
+ { 2, 2, _GUARD_IP_YIELD_VALUE_r22 },
+ { 3, 3, _GUARD_IP_YIELD_VALUE_r33 },
+ },
+ },
+ [_GUARD_IP_RETURN_VALUE] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _GUARD_IP_RETURN_VALUE_r00 },
+ { 1, 1, _GUARD_IP_RETURN_VALUE_r11 },
+ { 2, 2, _GUARD_IP_RETURN_VALUE_r22 },
+ { 3, 3, _GUARD_IP_RETURN_VALUE_r33 },
+ },
+ },
+ [_GUARD_IP_RETURN_GENERATOR] = {
+ .best = { 0, 1, 2, 3 },
+ .entries = {
+ { 0, 0, _GUARD_IP_RETURN_GENERATOR_r00 },
+ { 1, 1, _GUARD_IP_RETURN_GENERATOR_r11 },
+ { 2, 2, _GUARD_IP_RETURN_GENERATOR_r22 },
+ { 3, 3, _GUARD_IP_RETURN_GENERATOR_r33 },
+ },
+ },
+};
+
+const uint16_t _PyUop_Uncached[MAX_UOP_REGS_ID+1] = {
+ [_NOP_r00] = _NOP,
+ [_NOP_r11] = _NOP,
+ [_NOP_r22] = _NOP,
+ [_NOP_r33] = _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,
+ [_LOAD_FAST_CHECK_r01] = _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_1_r01] = _LOAD_FAST_1,
+ [_LOAD_FAST_1_r12] = _LOAD_FAST_1,
+ [_LOAD_FAST_1_r23] = _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_3_r01] = _LOAD_FAST_3,
+ [_LOAD_FAST_3_r12] = _LOAD_FAST_3,
+ [_LOAD_FAST_3_r23] = _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_5_r01] = _LOAD_FAST_5,
+ [_LOAD_FAST_5_r12] = _LOAD_FAST_5,
+ [_LOAD_FAST_5_r23] = _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_7_r01] = _LOAD_FAST_7,
+ [_LOAD_FAST_7_r12] = _LOAD_FAST_7,
+ [_LOAD_FAST_7_r23] = _LOAD_FAST_7,
+ [_LOAD_FAST_r01] = _LOAD_FAST,
+ [_LOAD_FAST_r12] = _LOAD_FAST,
+ [_LOAD_FAST_r23] = _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_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_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_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_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_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_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_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_r01] = _LOAD_FAST_BORROW,
+ [_LOAD_FAST_BORROW_r12] = _LOAD_FAST_BORROW,
+ [_LOAD_FAST_BORROW_r23] = _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_CONST_r01] = _LOAD_CONST,
+ [_LOAD_CONST_r12] = _LOAD_CONST,
+ [_LOAD_CONST_r23] = _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_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_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_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_r01] = _LOAD_SMALL_INT,
+ [_LOAD_SMALL_INT_r12] = _LOAD_SMALL_INT,
+ [_LOAD_SMALL_INT_r23] = _LOAD_SMALL_INT,
+ [_STORE_FAST_0_r10] = _STORE_FAST_0,
+ [_STORE_FAST_1_r10] = _STORE_FAST_1,
+ [_STORE_FAST_2_r10] = _STORE_FAST_2,
+ [_STORE_FAST_3_r10] = _STORE_FAST_3,
+ [_STORE_FAST_4_r10] = _STORE_FAST_4,
+ [_STORE_FAST_5_r10] = _STORE_FAST_5,
+ [_STORE_FAST_6_r10] = _STORE_FAST_6,
+ [_STORE_FAST_7_r10] = _STORE_FAST_7,
+ [_STORE_FAST_r10] = _STORE_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_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_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_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_TWO_r20] = _POP_TWO,
+ [_PUSH_NULL_r01] = _PUSH_NULL,
+ [_PUSH_NULL_r12] = _PUSH_NULL,
+ [_PUSH_NULL_r23] = _PUSH_NULL,
+ [_END_FOR_r10] = _END_FOR,
+ [_POP_ITER_r20] = _POP_ITER,
+ [_END_SEND_r21] = _END_SEND,
+ [_UNARY_NEGATIVE_r11] = _UNARY_NEGATIVE,
+ [_UNARY_NOT_r01] = _UNARY_NOT,
+ [_UNARY_NOT_r11] = _UNARY_NOT,
+ [_UNARY_NOT_r22] = _UNARY_NOT,
+ [_UNARY_NOT_r33] = _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_INT_r11] = _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_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_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,
+ [_TO_BOOL_LIST_r11] = _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,
+ [_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_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,
+ [_TO_BOOL_STR_r11] = _TO_BOOL_STR,
+ [_REPLACE_WITH_TRUE_r11] = _REPLACE_WITH_TRUE,
+ [_UNARY_INVERT_r11] = _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_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_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_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,
+ [_BINARY_OP_MULTIPLY_INT_r01] = _BINARY_OP_MULTIPLY_INT,
+ [_BINARY_OP_MULTIPLY_INT_r11] = _BINARY_OP_MULTIPLY_INT,
+ [_BINARY_OP_MULTIPLY_INT_r21] = _BINARY_OP_MULTIPLY_INT,
+ [_BINARY_OP_MULTIPLY_INT_r32] = _BINARY_OP_MULTIPLY_INT,
+ [_BINARY_OP_ADD_INT_r01] = _BINARY_OP_ADD_INT,
+ [_BINARY_OP_ADD_INT_r11] = _BINARY_OP_ADD_INT,
+ [_BINARY_OP_ADD_INT_r21] = _BINARY_OP_ADD_INT,
+ [_BINARY_OP_ADD_INT_r32] = _BINARY_OP_ADD_INT,
+ [_BINARY_OP_SUBTRACT_INT_r01] = _BINARY_OP_SUBTRACT_INT,
+ [_BINARY_OP_SUBTRACT_INT_r11] = _BINARY_OP_SUBTRACT_INT,
+ [_BINARY_OP_SUBTRACT_INT_r21] = _BINARY_OP_SUBTRACT_INT,
+ [_BINARY_OP_SUBTRACT_INT_r32] = _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_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,
+ [_BINARY_OP_MULTIPLY_FLOAT_r01] = _BINARY_OP_MULTIPLY_FLOAT,
+ [_BINARY_OP_MULTIPLY_FLOAT_r11] = _BINARY_OP_MULTIPLY_FLOAT,
+ [_BINARY_OP_MULTIPLY_FLOAT_r21] = _BINARY_OP_MULTIPLY_FLOAT,
+ [_BINARY_OP_MULTIPLY_FLOAT_r32] = _BINARY_OP_MULTIPLY_FLOAT,
+ [_BINARY_OP_ADD_FLOAT_r01] = _BINARY_OP_ADD_FLOAT,
+ [_BINARY_OP_ADD_FLOAT_r11] = _BINARY_OP_ADD_FLOAT,
+ [_BINARY_OP_ADD_FLOAT_r21] = _BINARY_OP_ADD_FLOAT,
+ [_BINARY_OP_ADD_FLOAT_r32] = _BINARY_OP_ADD_FLOAT,
+ [_BINARY_OP_SUBTRACT_FLOAT_r01] = _BINARY_OP_SUBTRACT_FLOAT,
+ [_BINARY_OP_SUBTRACT_FLOAT_r11] = _BINARY_OP_SUBTRACT_FLOAT,
+ [_BINARY_OP_SUBTRACT_FLOAT_r21] = _BINARY_OP_SUBTRACT_FLOAT,
+ [_BINARY_OP_SUBTRACT_FLOAT_r32] = _BINARY_OP_SUBTRACT_FLOAT,
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r01] = _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r11] = _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r21] = _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r32] = _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r01] = _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r11] = _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r21] = _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r32] = _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r01] = _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r11] = _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r21] = _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r32] = _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS,
+ [_BINARY_OP_ADD_UNICODE_r01] = _BINARY_OP_ADD_UNICODE,
+ [_BINARY_OP_ADD_UNICODE_r11] = _BINARY_OP_ADD_UNICODE,
+ [_BINARY_OP_ADD_UNICODE_r21] = _BINARY_OP_ADD_UNICODE,
+ [_BINARY_OP_ADD_UNICODE_r32] = _BINARY_OP_ADD_UNICODE,
+ [_BINARY_OP_INPLACE_ADD_UNICODE_r20] = _BINARY_OP_INPLACE_ADD_UNICODE,
+ [_GUARD_BINARY_OP_EXTEND_r22] = _GUARD_BINARY_OP_EXTEND,
+ [_BINARY_OP_EXTEND_r21] = _BINARY_OP_EXTEND,
+ [_BINARY_SLICE_r31] = _BINARY_SLICE,
+ [_STORE_SLICE_r30] = _STORE_SLICE,
+ [_BINARY_OP_SUBSCR_LIST_INT_r21] = _BINARY_OP_SUBSCR_LIST_INT,
+ [_BINARY_OP_SUBSCR_LIST_SLICE_r21] = _BINARY_OP_SUBSCR_LIST_SLICE,
+ [_BINARY_OP_SUBSCR_STR_INT_r21] = _BINARY_OP_SUBSCR_STR_INT,
+ [_GUARD_NOS_TUPLE_r02] = _GUARD_NOS_TUPLE,
+ [_GUARD_NOS_TUPLE_r12] = _GUARD_NOS_TUPLE,
+ [_GUARD_NOS_TUPLE_r22] = _GUARD_NOS_TUPLE,
+ [_GUARD_NOS_TUPLE_r33] = _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,
+ [_BINARY_OP_SUBSCR_TUPLE_INT_r21] = _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_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,
+ [_BINARY_OP_SUBSCR_DICT_r21] = _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,
+ [_LIST_APPEND_r10] = _LIST_APPEND,
+ [_SET_ADD_r10] = _SET_ADD,
+ [_STORE_SUBSCR_r30] = _STORE_SUBSCR,
+ [_STORE_SUBSCR_LIST_INT_r30] = _STORE_SUBSCR_LIST_INT,
+ [_STORE_SUBSCR_DICT_r30] = _STORE_SUBSCR_DICT,
+ [_DELETE_SUBSCR_r20] = _DELETE_SUBSCR,
+ [_CALL_INTRINSIC_1_r11] = _CALL_INTRINSIC_1,
+ [_CALL_INTRINSIC_2_r21] = _CALL_INTRINSIC_2,
+ [_RETURN_VALUE_r11] = _RETURN_VALUE,
+ [_GET_AITER_r11] = _GET_AITER,
+ [_GET_ANEXT_r12] = _GET_ANEXT,
+ [_GET_AWAITABLE_r11] = _GET_AWAITABLE,
+ [_SEND_GEN_FRAME_r22] = _SEND_GEN_FRAME,
+ [_YIELD_VALUE_r11] = _YIELD_VALUE,
+ [_POP_EXCEPT_r10] = _POP_EXCEPT,
+ [_LOAD_COMMON_CONSTANT_r01] = _LOAD_COMMON_CONSTANT,
+ [_LOAD_COMMON_CONSTANT_r12] = _LOAD_COMMON_CONSTANT,
+ [_LOAD_COMMON_CONSTANT_r23] = _LOAD_COMMON_CONSTANT,
+ [_LOAD_BUILD_CLASS_r01] = _LOAD_BUILD_CLASS,
+ [_STORE_NAME_r10] = _STORE_NAME,
+ [_DELETE_NAME_r00] = _DELETE_NAME,
+ [_UNPACK_SEQUENCE_r10] = _UNPACK_SEQUENCE,
+ [_UNPACK_SEQUENCE_TWO_TUPLE_r12] = _UNPACK_SEQUENCE_TWO_TUPLE,
+ [_UNPACK_SEQUENCE_TUPLE_r10] = _UNPACK_SEQUENCE_TUPLE,
+ [_UNPACK_SEQUENCE_LIST_r10] = _UNPACK_SEQUENCE_LIST,
+ [_UNPACK_EX_r10] = _UNPACK_EX,
+ [_STORE_ATTR_r20] = _STORE_ATTR,
+ [_DELETE_ATTR_r10] = _DELETE_ATTR,
+ [_STORE_GLOBAL_r10] = _STORE_GLOBAL,
+ [_DELETE_GLOBAL_r00] = _DELETE_GLOBAL,
+ [_LOAD_LOCALS_r01] = _LOAD_LOCALS,
+ [_LOAD_NAME_r01] = _LOAD_NAME,
+ [_LOAD_GLOBAL_r00] = _LOAD_GLOBAL,
+ [_PUSH_NULL_CONDITIONAL_r00] = _PUSH_NULL_CONDITIONAL,
+ [_GUARD_GLOBALS_VERSION_r00] = _GUARD_GLOBALS_VERSION,
+ [_GUARD_GLOBALS_VERSION_r11] = _GUARD_GLOBALS_VERSION,
+ [_GUARD_GLOBALS_VERSION_r22] = _GUARD_GLOBALS_VERSION,
+ [_GUARD_GLOBALS_VERSION_r33] = _GUARD_GLOBALS_VERSION,
+ [_LOAD_GLOBAL_MODULE_r01] = _LOAD_GLOBAL_MODULE,
+ [_LOAD_GLOBAL_BUILTINS_r01] = _LOAD_GLOBAL_BUILTINS,
+ [_DELETE_FAST_r00] = _DELETE_FAST,
+ [_MAKE_CELL_r00] = _MAKE_CELL,
+ [_DELETE_DEREF_r00] = _DELETE_DEREF,
+ [_LOAD_FROM_DICT_OR_DEREF_r11] = _LOAD_FROM_DICT_OR_DEREF,
+ [_LOAD_DEREF_r01] = _LOAD_DEREF,
+ [_STORE_DEREF_r10] = _STORE_DEREF,
+ [_COPY_FREE_VARS_r00] = _COPY_FREE_VARS,
+ [_COPY_FREE_VARS_r11] = _COPY_FREE_VARS,
+ [_COPY_FREE_VARS_r22] = _COPY_FREE_VARS,
+ [_COPY_FREE_VARS_r33] = _COPY_FREE_VARS,
+ [_BUILD_STRING_r01] = _BUILD_STRING,
+ [_BUILD_INTERPOLATION_r01] = _BUILD_INTERPOLATION,
+ [_BUILD_TEMPLATE_r21] = _BUILD_TEMPLATE,
+ [_BUILD_TUPLE_r01] = _BUILD_TUPLE,
+ [_BUILD_LIST_r01] = _BUILD_LIST,
+ [_LIST_EXTEND_r10] = _LIST_EXTEND,
+ [_SET_UPDATE_r10] = _SET_UPDATE,
+ [_BUILD_SET_r01] = _BUILD_SET,
+ [_BUILD_MAP_r01] = _BUILD_MAP,
+ [_SETUP_ANNOTATIONS_r00] = _SETUP_ANNOTATIONS,
+ [_DICT_UPDATE_r10] = _DICT_UPDATE,
+ [_DICT_MERGE_r10] = _DICT_MERGE,
+ [_MAP_ADD_r20] = _MAP_ADD,
+ [_LOAD_SUPER_ATTR_ATTR_r31] = _LOAD_SUPER_ATTR_ATTR,
+ [_LOAD_SUPER_ATTR_METHOD_r32] = _LOAD_SUPER_ATTR_METHOD,
+ [_LOAD_ATTR_r10] = _LOAD_ATTR,
+ [_GUARD_TYPE_VERSION_r01] = _GUARD_TYPE_VERSION,
+ [_GUARD_TYPE_VERSION_r11] = _GUARD_TYPE_VERSION,
+ [_GUARD_TYPE_VERSION_r22] = _GUARD_TYPE_VERSION,
+ [_GUARD_TYPE_VERSION_r33] = _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,
+ [_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,
+ [_LOAD_ATTR_INSTANCE_VALUE_r11] = _LOAD_ATTR_INSTANCE_VALUE,
+ [_LOAD_ATTR_MODULE_r11] = _LOAD_ATTR_MODULE,
+ [_LOAD_ATTR_WITH_HINT_r11] = _LOAD_ATTR_WITH_HINT,
+ [_LOAD_ATTR_SLOT_r11] = _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,
+ [_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,
+ [_STORE_ATTR_INSTANCE_VALUE_r20] = _STORE_ATTR_INSTANCE_VALUE,
+ [_STORE_ATTR_WITH_HINT_r20] = _STORE_ATTR_WITH_HINT,
+ [_STORE_ATTR_SLOT_r20] = _STORE_ATTR_SLOT,
+ [_COMPARE_OP_r21] = _COMPARE_OP,
+ [_COMPARE_OP_FLOAT_r01] = _COMPARE_OP_FLOAT,
+ [_COMPARE_OP_FLOAT_r11] = _COMPARE_OP_FLOAT,
+ [_COMPARE_OP_FLOAT_r21] = _COMPARE_OP_FLOAT,
+ [_COMPARE_OP_FLOAT_r32] = _COMPARE_OP_FLOAT,
+ [_COMPARE_OP_INT_r21] = _COMPARE_OP_INT,
+ [_COMPARE_OP_STR_r21] = _COMPARE_OP_STR,
+ [_IS_OP_r21] = _IS_OP,
+ [_CONTAINS_OP_r21] = _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,
+ [_CONTAINS_OP_SET_r21] = _CONTAINS_OP_SET,
+ [_CONTAINS_OP_DICT_r21] = _CONTAINS_OP_DICT,
+ [_CHECK_EG_MATCH_r22] = _CHECK_EG_MATCH,
+ [_CHECK_EXC_MATCH_r22] = _CHECK_EXC_MATCH,
+ [_IMPORT_NAME_r21] = _IMPORT_NAME,
+ [_IMPORT_FROM_r12] = _IMPORT_FROM,
+ [_IS_NONE_r11] = _IS_NONE,
+ [_GET_LEN_r12] = _GET_LEN,
+ [_MATCH_CLASS_r31] = _MATCH_CLASS,
+ [_MATCH_MAPPING_r02] = _MATCH_MAPPING,
+ [_MATCH_MAPPING_r12] = _MATCH_MAPPING,
+ [_MATCH_MAPPING_r23] = _MATCH_MAPPING,
+ [_MATCH_SEQUENCE_r02] = _MATCH_SEQUENCE,
+ [_MATCH_SEQUENCE_r12] = _MATCH_SEQUENCE,
+ [_MATCH_SEQUENCE_r23] = _MATCH_SEQUENCE,
+ [_MATCH_KEYS_r23] = _MATCH_KEYS,
+ [_GET_ITER_r12] = _GET_ITER,
+ [_GET_YIELD_FROM_ITER_r11] = _GET_YIELD_FROM_ITER,
+ [_FOR_ITER_TIER_TWO_r23] = _FOR_ITER_TIER_TWO,
+ [_ITER_CHECK_LIST_r02] = _ITER_CHECK_LIST,
+ [_ITER_CHECK_LIST_r12] = _ITER_CHECK_LIST,
+ [_ITER_CHECK_LIST_r22] = _ITER_CHECK_LIST,
+ [_ITER_CHECK_LIST_r33] = _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,
+ [_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,
+ [_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,
+ [_ITER_NEXT_TUPLE_r03] = _ITER_NEXT_TUPLE,
+ [_ITER_NEXT_TUPLE_r13] = _ITER_NEXT_TUPLE,
+ [_ITER_NEXT_TUPLE_r23] = _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,
+ [_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,
+ [_ITER_NEXT_RANGE_r03] = _ITER_NEXT_RANGE,
+ [_ITER_NEXT_RANGE_r13] = _ITER_NEXT_RANGE,
+ [_ITER_NEXT_RANGE_r23] = _ITER_NEXT_RANGE,
+ [_FOR_ITER_GEN_FRAME_r23] = _FOR_ITER_GEN_FRAME,
+ [_INSERT_NULL_r10] = _INSERT_NULL,
+ [_LOAD_SPECIAL_r00] = _LOAD_SPECIAL,
+ [_WITH_EXCEPT_START_r33] = _WITH_EXCEPT_START,
+ [_PUSH_EXC_INFO_r02] = _PUSH_EXC_INFO,
+ [_PUSH_EXC_INFO_r12] = _PUSH_EXC_INFO,
+ [_PUSH_EXC_INFO_r23] = _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_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,
+ [_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_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_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,
+ [_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,
+ [_MAYBE_EXPAND_METHOD_r00] = _MAYBE_EXPAND_METHOD,
+ [_PY_FRAME_GENERAL_r01] = _PY_FRAME_GENERAL,
+ [_CHECK_FUNCTION_VERSION_r00] = _CHECK_FUNCTION_VERSION,
+ [_CHECK_FUNCTION_VERSION_INLINE_r00] = _CHECK_FUNCTION_VERSION_INLINE,
+ [_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_METHOD_VERSION_r00] = _CHECK_METHOD_VERSION,
+ [_EXPAND_METHOD_r00] = _EXPAND_METHOD,
+ [_CHECK_IS_NOT_PY_CALLABLE_r00] = _CHECK_IS_NOT_PY_CALLABLE,
+ [_CALL_NON_PY_GENERAL_r01] = _CALL_NON_PY_GENERAL,
+ [_CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00] = _CHECK_CALL_BOUND_METHOD_EXACT_ARGS,
+ [_INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00] = _INIT_CALL_BOUND_METHOD_EXACT_ARGS,
+ [_CHECK_PEP_523_r00] = _CHECK_PEP_523,
+ [_CHECK_PEP_523_r11] = _CHECK_PEP_523,
+ [_CHECK_PEP_523_r22] = _CHECK_PEP_523,
+ [_CHECK_PEP_523_r33] = _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,
+ [_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,
+ [_INIT_CALL_PY_EXACT_ARGS_3_r01] = _INIT_CALL_PY_EXACT_ARGS_3,
+ [_INIT_CALL_PY_EXACT_ARGS_4_r01] = _INIT_CALL_PY_EXACT_ARGS_4,
+ [_INIT_CALL_PY_EXACT_ARGS_r01] = _INIT_CALL_PY_EXACT_ARGS,
+ [_PUSH_FRAME_r10] = _PUSH_FRAME,
+ [_GUARD_NOS_NULL_r02] = _GUARD_NOS_NULL,
+ [_GUARD_NOS_NULL_r12] = _GUARD_NOS_NULL,
+ [_GUARD_NOS_NULL_r22] = _GUARD_NOS_NULL,
+ [_GUARD_NOS_NULL_r33] = _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_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_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,
+ [_CALL_TYPE_1_r31] = _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,
+ [_CALL_STR_1_r31] = _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,
+ [_CALL_TUPLE_1_r31] = _CALL_TUPLE_1,
+ [_CHECK_AND_ALLOCATE_OBJECT_r00] = _CHECK_AND_ALLOCATE_OBJECT,
+ [_CREATE_INIT_FRAME_r01] = _CREATE_INIT_FRAME,
+ [_EXIT_INIT_CHECK_r10] = _EXIT_INIT_CHECK,
+ [_CALL_BUILTIN_CLASS_r01] = _CALL_BUILTIN_CLASS,
+ [_CALL_BUILTIN_O_r01] = _CALL_BUILTIN_O,
+ [_CALL_BUILTIN_FAST_r01] = _CALL_BUILTIN_FAST,
+ [_CALL_BUILTIN_FAST_WITH_KEYWORDS_r01] = _CALL_BUILTIN_FAST_WITH_KEYWORDS,
+ [_GUARD_CALLABLE_LEN_r03] = _GUARD_CALLABLE_LEN,
+ [_GUARD_CALLABLE_LEN_r13] = _GUARD_CALLABLE_LEN,
+ [_GUARD_CALLABLE_LEN_r23] = _GUARD_CALLABLE_LEN,
+ [_GUARD_CALLABLE_LEN_r33] = _GUARD_CALLABLE_LEN,
+ [_CALL_LEN_r31] = _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_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,
+ [_CALL_LIST_APPEND_r30] = _CALL_LIST_APPEND,
+ [_CALL_METHOD_DESCRIPTOR_O_r01] = _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,
+ [_MAYBE_EXPAND_METHOD_KW_r11] = _MAYBE_EXPAND_METHOD_KW,
+ [_PY_FRAME_KW_r11] = _PY_FRAME_KW,
+ [_CHECK_FUNCTION_VERSION_KW_r11] = _CHECK_FUNCTION_VERSION_KW,
+ [_CHECK_METHOD_VERSION_KW_r11] = _CHECK_METHOD_VERSION_KW,
+ [_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,
+ [_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,
+ [_RETURN_GENERATOR_r01] = _RETURN_GENERATOR,
+ [_BUILD_SLICE_r01] = _BUILD_SLICE,
+ [_CONVERT_VALUE_r11] = _CONVERT_VALUE,
+ [_FORMAT_SIMPLE_r11] = _FORMAT_SIMPLE,
+ [_FORMAT_WITH_SPEC_r21] = _FORMAT_WITH_SPEC,
+ [_COPY_1_r02] = _COPY_1,
+ [_COPY_1_r12] = _COPY_1,
+ [_COPY_1_r23] = _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_r01] = _COPY,
+ [_BINARY_OP_r21] = _BINARY_OP,
+ [_SWAP_2_r02] = _SWAP_2,
+ [_SWAP_2_r12] = _SWAP_2,
+ [_SWAP_2_r22] = _SWAP_2,
+ [_SWAP_2_r33] = _SWAP_2,
+ [_SWAP_3_r03] = _SWAP_3,
+ [_SWAP_3_r13] = _SWAP_3,
+ [_SWAP_3_r23] = _SWAP_3,
+ [_SWAP_3_r33] = _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_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_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_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,
+ [_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,
+ [_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,
+ [_EXIT_TRACE_r00] = _EXIT_TRACE,
+ [_EXIT_TRACE_r10] = _EXIT_TRACE,
+ [_EXIT_TRACE_r20] = _EXIT_TRACE,
+ [_EXIT_TRACE_r30] = _EXIT_TRACE,
+ [_DYNAMIC_EXIT_r00] = _DYNAMIC_EXIT,
+ [_DYNAMIC_EXIT_r10] = _DYNAMIC_EXIT,
+ [_DYNAMIC_EXIT_r20] = _DYNAMIC_EXIT,
+ [_DYNAMIC_EXIT_r30] = _DYNAMIC_EXIT,
+ [_CHECK_VALIDITY_r00] = _CHECK_VALIDITY,
+ [_CHECK_VALIDITY_r11] = _CHECK_VALIDITY,
+ [_CHECK_VALIDITY_r22] = _CHECK_VALIDITY,
+ [_CHECK_VALIDITY_r33] = _CHECK_VALIDITY,
+ [_LOAD_CONST_INLINE_r01] = _LOAD_CONST_INLINE,
+ [_LOAD_CONST_INLINE_r12] = _LOAD_CONST_INLINE,
+ [_LOAD_CONST_INLINE_r23] = _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,
+ [_POP_CALL_r20] = _POP_CALL,
+ [_POP_CALL_ONE_r30] = _POP_CALL_ONE,
+ [_POP_CALL_TWO_r30] = _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,
+ [_POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31] = _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW,
+ [_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31] = _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_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,
+ [_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,
+ [_FATAL_ERROR_r00] = _FATAL_ERROR,
+ [_FATAL_ERROR_r11] = _FATAL_ERROR,
+ [_FATAL_ERROR_r22] = _FATAL_ERROR,
+ [_FATAL_ERROR_r33] = _FATAL_ERROR,
+ [_DEOPT_r00] = _DEOPT,
+ [_DEOPT_r10] = _DEOPT,
+ [_DEOPT_r20] = _DEOPT,
+ [_DEOPT_r30] = _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,
+ [_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_r10] = _SPILL_OR_RELOAD,
+ [_SPILL_OR_RELOAD_r12] = _SPILL_OR_RELOAD,
+ [_SPILL_OR_RELOAD_r13] = _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_r30] = _SPILL_OR_RELOAD,
+ [_SPILL_OR_RELOAD_r31] = _SPILL_OR_RELOAD,
+ [_SPILL_OR_RELOAD_r32] = _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,
+ [_COLD_EXIT_r00] = _COLD_EXIT,
+ [_COLD_DYNAMIC_EXIT_r00] = _COLD_DYNAMIC_EXIT,
+ [_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_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_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_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,
+};
+
+const uint16_t _PyUop_SpillsAndReloads[4][4] = {
+ [0][1] = _SPILL_OR_RELOAD_r01,
+ [0][2] = _SPILL_OR_RELOAD_r02,
+ [0][3] = _SPILL_OR_RELOAD_r03,
+ [1][0] = _SPILL_OR_RELOAD_r10,
+ [1][2] = _SPILL_OR_RELOAD_r12,
+ [1][3] = _SPILL_OR_RELOAD_r13,
+ [2][0] = _SPILL_OR_RELOAD_r20,
+ [2][1] = _SPILL_OR_RELOAD_r21,
+ [2][3] = _SPILL_OR_RELOAD_r23,
+ [3][0] = _SPILL_OR_RELOAD_r30,
+ [3][1] = _SPILL_OR_RELOAD_r31,
+ [3][2] = _SPILL_OR_RELOAD_r32,
+};
+
+const char *const _PyOpcode_uop_name[MAX_UOP_REGS_ID+1] = {
[_BINARY_OP] = "_BINARY_OP",
+ [_BINARY_OP_r21] = "_BINARY_OP_r21",
[_BINARY_OP_ADD_FLOAT] = "_BINARY_OP_ADD_FLOAT",
+ [_BINARY_OP_ADD_FLOAT_r01] = "_BINARY_OP_ADD_FLOAT_r01",
+ [_BINARY_OP_ADD_FLOAT_r11] = "_BINARY_OP_ADD_FLOAT_r11",
+ [_BINARY_OP_ADD_FLOAT_r21] = "_BINARY_OP_ADD_FLOAT_r21",
+ [_BINARY_OP_ADD_FLOAT_r32] = "_BINARY_OP_ADD_FLOAT_r32",
[_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS] = "_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS",
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r01] = "_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r01",
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r11] = "_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r11",
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r21] = "_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r21",
+ [_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r32] = "_BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r32",
[_BINARY_OP_ADD_INT] = "_BINARY_OP_ADD_INT",
+ [_BINARY_OP_ADD_INT_r01] = "_BINARY_OP_ADD_INT_r01",
+ [_BINARY_OP_ADD_INT_r11] = "_BINARY_OP_ADD_INT_r11",
+ [_BINARY_OP_ADD_INT_r21] = "_BINARY_OP_ADD_INT_r21",
+ [_BINARY_OP_ADD_INT_r32] = "_BINARY_OP_ADD_INT_r32",
[_BINARY_OP_ADD_UNICODE] = "_BINARY_OP_ADD_UNICODE",
+ [_BINARY_OP_ADD_UNICODE_r01] = "_BINARY_OP_ADD_UNICODE_r01",
+ [_BINARY_OP_ADD_UNICODE_r11] = "_BINARY_OP_ADD_UNICODE_r11",
+ [_BINARY_OP_ADD_UNICODE_r21] = "_BINARY_OP_ADD_UNICODE_r21",
+ [_BINARY_OP_ADD_UNICODE_r32] = "_BINARY_OP_ADD_UNICODE_r32",
[_BINARY_OP_EXTEND] = "_BINARY_OP_EXTEND",
+ [_BINARY_OP_EXTEND_r21] = "_BINARY_OP_EXTEND_r21",
[_BINARY_OP_INPLACE_ADD_UNICODE] = "_BINARY_OP_INPLACE_ADD_UNICODE",
+ [_BINARY_OP_INPLACE_ADD_UNICODE_r20] = "_BINARY_OP_INPLACE_ADD_UNICODE_r20",
[_BINARY_OP_MULTIPLY_FLOAT] = "_BINARY_OP_MULTIPLY_FLOAT",
+ [_BINARY_OP_MULTIPLY_FLOAT_r01] = "_BINARY_OP_MULTIPLY_FLOAT_r01",
+ [_BINARY_OP_MULTIPLY_FLOAT_r11] = "_BINARY_OP_MULTIPLY_FLOAT_r11",
+ [_BINARY_OP_MULTIPLY_FLOAT_r21] = "_BINARY_OP_MULTIPLY_FLOAT_r21",
+ [_BINARY_OP_MULTIPLY_FLOAT_r32] = "_BINARY_OP_MULTIPLY_FLOAT_r32",
[_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS] = "_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS",
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r01] = "_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r01",
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r11] = "_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r11",
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r21] = "_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r21",
+ [_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r32] = "_BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r32",
[_BINARY_OP_MULTIPLY_INT] = "_BINARY_OP_MULTIPLY_INT",
+ [_BINARY_OP_MULTIPLY_INT_r01] = "_BINARY_OP_MULTIPLY_INT_r01",
+ [_BINARY_OP_MULTIPLY_INT_r11] = "_BINARY_OP_MULTIPLY_INT_r11",
+ [_BINARY_OP_MULTIPLY_INT_r21] = "_BINARY_OP_MULTIPLY_INT_r21",
+ [_BINARY_OP_MULTIPLY_INT_r32] = "_BINARY_OP_MULTIPLY_INT_r32",
[_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",
+ [_BINARY_OP_SUBSCR_DICT_r21] = "_BINARY_OP_SUBSCR_DICT_r21",
[_BINARY_OP_SUBSCR_INIT_CALL] = "_BINARY_OP_SUBSCR_INIT_CALL",
+ [_BINARY_OP_SUBSCR_INIT_CALL_r01] = "_BINARY_OP_SUBSCR_INIT_CALL_r01",
+ [_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_LIST_INT] = "_BINARY_OP_SUBSCR_LIST_INT",
+ [_BINARY_OP_SUBSCR_LIST_INT_r21] = "_BINARY_OP_SUBSCR_LIST_INT_r21",
[_BINARY_OP_SUBSCR_LIST_SLICE] = "_BINARY_OP_SUBSCR_LIST_SLICE",
+ [_BINARY_OP_SUBSCR_LIST_SLICE_r21] = "_BINARY_OP_SUBSCR_LIST_SLICE_r21",
[_BINARY_OP_SUBSCR_STR_INT] = "_BINARY_OP_SUBSCR_STR_INT",
+ [_BINARY_OP_SUBSCR_STR_INT_r21] = "_BINARY_OP_SUBSCR_STR_INT_r21",
[_BINARY_OP_SUBSCR_TUPLE_INT] = "_BINARY_OP_SUBSCR_TUPLE_INT",
+ [_BINARY_OP_SUBSCR_TUPLE_INT_r21] = "_BINARY_OP_SUBSCR_TUPLE_INT_r21",
[_BINARY_OP_SUBTRACT_FLOAT] = "_BINARY_OP_SUBTRACT_FLOAT",
+ [_BINARY_OP_SUBTRACT_FLOAT_r01] = "_BINARY_OP_SUBTRACT_FLOAT_r01",
+ [_BINARY_OP_SUBTRACT_FLOAT_r11] = "_BINARY_OP_SUBTRACT_FLOAT_r11",
+ [_BINARY_OP_SUBTRACT_FLOAT_r21] = "_BINARY_OP_SUBTRACT_FLOAT_r21",
+ [_BINARY_OP_SUBTRACT_FLOAT_r32] = "_BINARY_OP_SUBTRACT_FLOAT_r32",
[_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS] = "_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS",
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r01] = "_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r01",
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r11] = "_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r11",
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r21] = "_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r21",
+ [_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r32] = "_BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r32",
[_BINARY_OP_SUBTRACT_INT] = "_BINARY_OP_SUBTRACT_INT",
+ [_BINARY_OP_SUBTRACT_INT_r01] = "_BINARY_OP_SUBTRACT_INT_r01",
+ [_BINARY_OP_SUBTRACT_INT_r11] = "_BINARY_OP_SUBTRACT_INT_r11",
+ [_BINARY_OP_SUBTRACT_INT_r21] = "_BINARY_OP_SUBTRACT_INT_r21",
+ [_BINARY_OP_SUBTRACT_INT_r32] = "_BINARY_OP_SUBTRACT_INT_r32",
[_BINARY_SLICE] = "_BINARY_SLICE",
+ [_BINARY_SLICE_r31] = "_BINARY_SLICE_r31",
[_BUILD_INTERPOLATION] = "_BUILD_INTERPOLATION",
+ [_BUILD_INTERPOLATION_r01] = "_BUILD_INTERPOLATION_r01",
[_BUILD_LIST] = "_BUILD_LIST",
+ [_BUILD_LIST_r01] = "_BUILD_LIST_r01",
[_BUILD_MAP] = "_BUILD_MAP",
+ [_BUILD_MAP_r01] = "_BUILD_MAP_r01",
[_BUILD_SET] = "_BUILD_SET",
+ [_BUILD_SET_r01] = "_BUILD_SET_r01",
[_BUILD_SLICE] = "_BUILD_SLICE",
+ [_BUILD_SLICE_r01] = "_BUILD_SLICE_r01",
[_BUILD_STRING] = "_BUILD_STRING",
+ [_BUILD_STRING_r01] = "_BUILD_STRING_r01",
[_BUILD_TEMPLATE] = "_BUILD_TEMPLATE",
+ [_BUILD_TEMPLATE_r21] = "_BUILD_TEMPLATE_r21",
[_BUILD_TUPLE] = "_BUILD_TUPLE",
+ [_BUILD_TUPLE_r01] = "_BUILD_TUPLE_r01",
[_CALL_BUILTIN_CLASS] = "_CALL_BUILTIN_CLASS",
+ [_CALL_BUILTIN_CLASS_r01] = "_CALL_BUILTIN_CLASS_r01",
[_CALL_BUILTIN_FAST] = "_CALL_BUILTIN_FAST",
+ [_CALL_BUILTIN_FAST_r01] = "_CALL_BUILTIN_FAST_r01",
[_CALL_BUILTIN_FAST_WITH_KEYWORDS] = "_CALL_BUILTIN_FAST_WITH_KEYWORDS",
+ [_CALL_BUILTIN_FAST_WITH_KEYWORDS_r01] = "_CALL_BUILTIN_FAST_WITH_KEYWORDS_r01",
[_CALL_BUILTIN_O] = "_CALL_BUILTIN_O",
+ [_CALL_BUILTIN_O_r01] = "_CALL_BUILTIN_O_r01",
[_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_KW_NON_PY] = "_CALL_KW_NON_PY",
+ [_CALL_KW_NON_PY_r11] = "_CALL_KW_NON_PY_r11",
[_CALL_LEN] = "_CALL_LEN",
+ [_CALL_LEN_r31] = "_CALL_LEN_r31",
[_CALL_LIST_APPEND] = "_CALL_LIST_APPEND",
+ [_CALL_LIST_APPEND_r30] = "_CALL_LIST_APPEND_r30",
[_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",
+ [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01] = "_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01",
[_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_r01] = "_CALL_METHOD_DESCRIPTOR_O_r01",
[_CALL_NON_PY_GENERAL] = "_CALL_NON_PY_GENERAL",
+ [_CALL_NON_PY_GENERAL_r01] = "_CALL_NON_PY_GENERAL_r01",
[_CALL_STR_1] = "_CALL_STR_1",
+ [_CALL_STR_1_r31] = "_CALL_STR_1_r31",
[_CALL_TUPLE_1] = "_CALL_TUPLE_1",
+ [_CALL_TUPLE_1_r31] = "_CALL_TUPLE_1_r31",
[_CALL_TYPE_1] = "_CALL_TYPE_1",
+ [_CALL_TYPE_1_r31] = "_CALL_TYPE_1_r31",
[_CHECK_AND_ALLOCATE_OBJECT] = "_CHECK_AND_ALLOCATE_OBJECT",
+ [_CHECK_AND_ALLOCATE_OBJECT_r00] = "_CHECK_AND_ALLOCATE_OBJECT_r00",
[_CHECK_ATTR_CLASS] = "_CHECK_ATTR_CLASS",
+ [_CHECK_ATTR_CLASS_r01] = "_CHECK_ATTR_CLASS_r01",
+ [_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_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_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",
+ [_CHECK_EG_MATCH_r22] = "_CHECK_EG_MATCH_r22",
[_CHECK_EXC_MATCH] = "_CHECK_EXC_MATCH",
+ [_CHECK_EXC_MATCH_r22] = "_CHECK_EXC_MATCH_r22",
[_CHECK_FUNCTION_EXACT_ARGS] = "_CHECK_FUNCTION_EXACT_ARGS",
+ [_CHECK_FUNCTION_EXACT_ARGS_r00] = "_CHECK_FUNCTION_EXACT_ARGS_r00",
[_CHECK_FUNCTION_VERSION] = "_CHECK_FUNCTION_VERSION",
+ [_CHECK_FUNCTION_VERSION_r00] = "_CHECK_FUNCTION_VERSION_r00",
[_CHECK_FUNCTION_VERSION_INLINE] = "_CHECK_FUNCTION_VERSION_INLINE",
+ [_CHECK_FUNCTION_VERSION_INLINE_r00] = "_CHECK_FUNCTION_VERSION_INLINE_r00",
+ [_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_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_KW] = "_CHECK_IS_NOT_PY_CALLABLE_KW",
+ [_CHECK_IS_NOT_PY_CALLABLE_KW_r11] = "_CHECK_IS_NOT_PY_CALLABLE_KW_r11",
[_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_METHOD_VERSION] = "_CHECK_METHOD_VERSION",
+ [_CHECK_METHOD_VERSION_r00] = "_CHECK_METHOD_VERSION_r00",
[_CHECK_METHOD_VERSION_KW] = "_CHECK_METHOD_VERSION_KW",
+ [_CHECK_METHOD_VERSION_KW_r11] = "_CHECK_METHOD_VERSION_KW_r11",
[_CHECK_PEP_523] = "_CHECK_PEP_523",
+ [_CHECK_PEP_523_r00] = "_CHECK_PEP_523_r00",
+ [_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_PERIODIC] = "_CHECK_PERIODIC",
+ [_CHECK_PERIODIC_r00] = "_CHECK_PERIODIC_r00",
[_CHECK_PERIODIC_IF_NOT_YIELD_FROM] = "_CHECK_PERIODIC_IF_NOT_YIELD_FROM",
+ [_CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00] = "_CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00",
[_CHECK_RECURSION_REMAINING] = "_CHECK_RECURSION_REMAINING",
+ [_CHECK_RECURSION_REMAINING_r00] = "_CHECK_RECURSION_REMAINING_r00",
+ [_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_STACK_SPACE] = "_CHECK_STACK_SPACE",
+ [_CHECK_STACK_SPACE_r00] = "_CHECK_STACK_SPACE_r00",
[_CHECK_STACK_SPACE_OPERAND] = "_CHECK_STACK_SPACE_OPERAND",
+ [_CHECK_STACK_SPACE_OPERAND_r00] = "_CHECK_STACK_SPACE_OPERAND_r00",
+ [_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_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",
[_COLD_DYNAMIC_EXIT] = "_COLD_DYNAMIC_EXIT",
+ [_COLD_DYNAMIC_EXIT_r00] = "_COLD_DYNAMIC_EXIT_r00",
[_COLD_EXIT] = "_COLD_EXIT",
+ [_COLD_EXIT_r00] = "_COLD_EXIT_r00",
[_COMPARE_OP] = "_COMPARE_OP",
+ [_COMPARE_OP_r21] = "_COMPARE_OP_r21",
[_COMPARE_OP_FLOAT] = "_COMPARE_OP_FLOAT",
+ [_COMPARE_OP_FLOAT_r01] = "_COMPARE_OP_FLOAT_r01",
+ [_COMPARE_OP_FLOAT_r11] = "_COMPARE_OP_FLOAT_r11",
+ [_COMPARE_OP_FLOAT_r21] = "_COMPARE_OP_FLOAT_r21",
+ [_COMPARE_OP_FLOAT_r32] = "_COMPARE_OP_FLOAT_r32",
[_COMPARE_OP_INT] = "_COMPARE_OP_INT",
+ [_COMPARE_OP_INT_r21] = "_COMPARE_OP_INT_r21",
[_COMPARE_OP_STR] = "_COMPARE_OP_STR",
+ [_COMPARE_OP_STR_r21] = "_COMPARE_OP_STR_r21",
[_CONTAINS_OP] = "_CONTAINS_OP",
+ [_CONTAINS_OP_r21] = "_CONTAINS_OP_r21",
[_CONTAINS_OP_DICT] = "_CONTAINS_OP_DICT",
+ [_CONTAINS_OP_DICT_r21] = "_CONTAINS_OP_DICT_r21",
[_CONTAINS_OP_SET] = "_CONTAINS_OP_SET",
+ [_CONTAINS_OP_SET_r21] = "_CONTAINS_OP_SET_r21",
[_CONVERT_VALUE] = "_CONVERT_VALUE",
+ [_CONVERT_VALUE_r11] = "_CONVERT_VALUE_r11",
[_COPY] = "_COPY",
+ [_COPY_r01] = "_COPY_r01",
[_COPY_1] = "_COPY_1",
+ [_COPY_1_r02] = "_COPY_1_r02",
+ [_COPY_1_r12] = "_COPY_1_r12",
+ [_COPY_1_r23] = "_COPY_1_r23",
[_COPY_2] = "_COPY_2",
+ [_COPY_2_r03] = "_COPY_2_r03",
+ [_COPY_2_r13] = "_COPY_2_r13",
+ [_COPY_2_r23] = "_COPY_2_r23",
[_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_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",
[_CREATE_INIT_FRAME] = "_CREATE_INIT_FRAME",
+ [_CREATE_INIT_FRAME_r01] = "_CREATE_INIT_FRAME_r01",
[_DELETE_ATTR] = "_DELETE_ATTR",
+ [_DELETE_ATTR_r10] = "_DELETE_ATTR_r10",
[_DELETE_DEREF] = "_DELETE_DEREF",
+ [_DELETE_DEREF_r00] = "_DELETE_DEREF_r00",
[_DELETE_FAST] = "_DELETE_FAST",
+ [_DELETE_FAST_r00] = "_DELETE_FAST_r00",
[_DELETE_GLOBAL] = "_DELETE_GLOBAL",
+ [_DELETE_GLOBAL_r00] = "_DELETE_GLOBAL_r00",
[_DELETE_NAME] = "_DELETE_NAME",
+ [_DELETE_NAME_r00] = "_DELETE_NAME_r00",
[_DELETE_SUBSCR] = "_DELETE_SUBSCR",
+ [_DELETE_SUBSCR_r20] = "_DELETE_SUBSCR_r20",
[_DEOPT] = "_DEOPT",
+ [_DEOPT_r00] = "_DEOPT_r00",
+ [_DEOPT_r10] = "_DEOPT_r10",
+ [_DEOPT_r20] = "_DEOPT_r20",
+ [_DEOPT_r30] = "_DEOPT_r30",
[_DICT_MERGE] = "_DICT_MERGE",
+ [_DICT_MERGE_r10] = "_DICT_MERGE_r10",
[_DICT_UPDATE] = "_DICT_UPDATE",
+ [_DICT_UPDATE_r10] = "_DICT_UPDATE_r10",
[_DYNAMIC_EXIT] = "_DYNAMIC_EXIT",
+ [_DYNAMIC_EXIT_r00] = "_DYNAMIC_EXIT_r00",
+ [_DYNAMIC_EXIT_r10] = "_DYNAMIC_EXIT_r10",
+ [_DYNAMIC_EXIT_r20] = "_DYNAMIC_EXIT_r20",
+ [_DYNAMIC_EXIT_r30] = "_DYNAMIC_EXIT_r30",
[_END_FOR] = "_END_FOR",
+ [_END_FOR_r10] = "_END_FOR_r10",
[_END_SEND] = "_END_SEND",
+ [_END_SEND_r21] = "_END_SEND_r21",
[_ERROR_POP_N] = "_ERROR_POP_N",
+ [_ERROR_POP_N_r00] = "_ERROR_POP_N_r00",
[_EXIT_INIT_CHECK] = "_EXIT_INIT_CHECK",
+ [_EXIT_INIT_CHECK_r10] = "_EXIT_INIT_CHECK_r10",
[_EXIT_TRACE] = "_EXIT_TRACE",
+ [_EXIT_TRACE_r00] = "_EXIT_TRACE_r00",
+ [_EXIT_TRACE_r10] = "_EXIT_TRACE_r10",
+ [_EXIT_TRACE_r20] = "_EXIT_TRACE_r20",
+ [_EXIT_TRACE_r30] = "_EXIT_TRACE_r30",
[_EXPAND_METHOD] = "_EXPAND_METHOD",
+ [_EXPAND_METHOD_r00] = "_EXPAND_METHOD_r00",
[_EXPAND_METHOD_KW] = "_EXPAND_METHOD_KW",
+ [_EXPAND_METHOD_KW_r11] = "_EXPAND_METHOD_KW_r11",
[_FATAL_ERROR] = "_FATAL_ERROR",
+ [_FATAL_ERROR_r00] = "_FATAL_ERROR_r00",
+ [_FATAL_ERROR_r11] = "_FATAL_ERROR_r11",
+ [_FATAL_ERROR_r22] = "_FATAL_ERROR_r22",
+ [_FATAL_ERROR_r33] = "_FATAL_ERROR_r33",
[_FORMAT_SIMPLE] = "_FORMAT_SIMPLE",
+ [_FORMAT_SIMPLE_r11] = "_FORMAT_SIMPLE_r11",
[_FORMAT_WITH_SPEC] = "_FORMAT_WITH_SPEC",
+ [_FORMAT_WITH_SPEC_r21] = "_FORMAT_WITH_SPEC_r21",
[_FOR_ITER_GEN_FRAME] = "_FOR_ITER_GEN_FRAME",
+ [_FOR_ITER_GEN_FRAME_r23] = "_FOR_ITER_GEN_FRAME_r23",
[_FOR_ITER_TIER_TWO] = "_FOR_ITER_TIER_TWO",
+ [_FOR_ITER_TIER_TWO_r23] = "_FOR_ITER_TIER_TWO_r23",
[_GET_AITER] = "_GET_AITER",
+ [_GET_AITER_r11] = "_GET_AITER_r11",
[_GET_ANEXT] = "_GET_ANEXT",
+ [_GET_ANEXT_r12] = "_GET_ANEXT_r12",
[_GET_AWAITABLE] = "_GET_AWAITABLE",
+ [_GET_AWAITABLE_r11] = "_GET_AWAITABLE_r11",
[_GET_ITER] = "_GET_ITER",
+ [_GET_ITER_r12] = "_GET_ITER_r12",
[_GET_LEN] = "_GET_LEN",
+ [_GET_LEN_r12] = "_GET_LEN_r12",
[_GET_YIELD_FROM_ITER] = "_GET_YIELD_FROM_ITER",
+ [_GET_YIELD_FROM_ITER_r11] = "_GET_YIELD_FROM_ITER_r11",
[_GUARD_BINARY_OP_EXTEND] = "_GUARD_BINARY_OP_EXTEND",
+ [_GUARD_BINARY_OP_EXTEND_r22] = "_GUARD_BINARY_OP_EXTEND_r22",
[_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_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_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_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_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_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_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_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_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_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_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_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__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_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_NONE_POP] = "_GUARD_IS_NONE_POP",
+ [_GUARD_IS_NONE_POP_r00] = "_GUARD_IS_NONE_POP_r00",
+ [_GUARD_IS_NONE_POP_r10] = "_GUARD_IS_NONE_POP_r10",
+ [_GUARD_IS_NONE_POP_r21] = "_GUARD_IS_NONE_POP_r21",
+ [_GUARD_IS_NONE_POP_r32] = "_GUARD_IS_NONE_POP_r32",
[_GUARD_IS_NOT_NONE_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",
+ [_GUARD_IS_TRUE_POP_r00] = "_GUARD_IS_TRUE_POP_r00",
+ [_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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",
[_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",
[_IMPORT_FROM] = "_IMPORT_FROM",
+ [_IMPORT_FROM_r12] = "_IMPORT_FROM_r12",
[_IMPORT_NAME] = "_IMPORT_NAME",
+ [_IMPORT_NAME_r21] = "_IMPORT_NAME_r21",
[_INIT_CALL_BOUND_METHOD_EXACT_ARGS] = "_INIT_CALL_BOUND_METHOD_EXACT_ARGS",
+ [_INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00] = "_INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00",
[_INIT_CALL_PY_EXACT_ARGS] = "_INIT_CALL_PY_EXACT_ARGS",
+ [_INIT_CALL_PY_EXACT_ARGS_r01] = "_INIT_CALL_PY_EXACT_ARGS_r01",
[_INIT_CALL_PY_EXACT_ARGS_0] = "_INIT_CALL_PY_EXACT_ARGS_0",
+ [_INIT_CALL_PY_EXACT_ARGS_0_r01] = "_INIT_CALL_PY_EXACT_ARGS_0_r01",
[_INIT_CALL_PY_EXACT_ARGS_1] = "_INIT_CALL_PY_EXACT_ARGS_1",
+ [_INIT_CALL_PY_EXACT_ARGS_1_r01] = "_INIT_CALL_PY_EXACT_ARGS_1_r01",
[_INIT_CALL_PY_EXACT_ARGS_2] = "_INIT_CALL_PY_EXACT_ARGS_2",
+ [_INIT_CALL_PY_EXACT_ARGS_2_r01] = "_INIT_CALL_PY_EXACT_ARGS_2_r01",
[_INIT_CALL_PY_EXACT_ARGS_3] = "_INIT_CALL_PY_EXACT_ARGS_3",
+ [_INIT_CALL_PY_EXACT_ARGS_3_r01] = "_INIT_CALL_PY_EXACT_ARGS_3_r01",
[_INIT_CALL_PY_EXACT_ARGS_4] = "_INIT_CALL_PY_EXACT_ARGS_4",
+ [_INIT_CALL_PY_EXACT_ARGS_4_r01] = "_INIT_CALL_PY_EXACT_ARGS_4_r01",
[_INSERT_NULL] = "_INSERT_NULL",
+ [_INSERT_NULL_r10] = "_INSERT_NULL_r10",
[_IS_NONE] = "_IS_NONE",
+ [_IS_NONE_r11] = "_IS_NONE_r11",
[_IS_OP] = "_IS_OP",
+ [_IS_OP_r21] = "_IS_OP_r21",
[_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_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_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_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_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",
[_JUMP_TO_TOP] = "_JUMP_TO_TOP",
+ [_JUMP_TO_TOP_r00] = "_JUMP_TO_TOP_r00",
[_LIST_APPEND] = "_LIST_APPEND",
+ [_LIST_APPEND_r10] = "_LIST_APPEND_r10",
[_LIST_EXTEND] = "_LIST_EXTEND",
+ [_LIST_EXTEND_r10] = "_LIST_EXTEND_r10",
[_LOAD_ATTR] = "_LOAD_ATTR",
+ [_LOAD_ATTR_r10] = "_LOAD_ATTR_r10",
[_LOAD_ATTR_CLASS] = "_LOAD_ATTR_CLASS",
+ [_LOAD_ATTR_CLASS_r11] = "_LOAD_ATTR_CLASS_r11",
[_LOAD_ATTR_INSTANCE_VALUE] = "_LOAD_ATTR_INSTANCE_VALUE",
+ [_LOAD_ATTR_INSTANCE_VALUE_r11] = "_LOAD_ATTR_INSTANCE_VALUE_r11",
[_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_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_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_MODULE] = "_LOAD_ATTR_MODULE",
+ [_LOAD_ATTR_MODULE_r11] = "_LOAD_ATTR_MODULE_r11",
[_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = "_LOAD_ATTR_NONDESCRIPTOR_NO_DICT",
+ [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11] = "_LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11",
[_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = "_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES",
+ [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11] = "_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11",
[_LOAD_ATTR_PROPERTY_FRAME] = "_LOAD_ATTR_PROPERTY_FRAME",
+ [_LOAD_ATTR_PROPERTY_FRAME_r11] = "_LOAD_ATTR_PROPERTY_FRAME_r11",
[_LOAD_ATTR_SLOT] = "_LOAD_ATTR_SLOT",
+ [_LOAD_ATTR_SLOT_r11] = "_LOAD_ATTR_SLOT_r11",
[_LOAD_ATTR_WITH_HINT] = "_LOAD_ATTR_WITH_HINT",
+ [_LOAD_ATTR_WITH_HINT_r11] = "_LOAD_ATTR_WITH_HINT_r11",
[_LOAD_BUILD_CLASS] = "_LOAD_BUILD_CLASS",
+ [_LOAD_BUILD_CLASS_r01] = "_LOAD_BUILD_CLASS_r01",
[_LOAD_COMMON_CONSTANT] = "_LOAD_COMMON_CONSTANT",
+ [_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_CONST] = "_LOAD_CONST",
+ [_LOAD_CONST_r01] = "_LOAD_CONST_r01",
+ [_LOAD_CONST_r12] = "_LOAD_CONST_r12",
+ [_LOAD_CONST_r23] = "_LOAD_CONST_r23",
[_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_7] = "_LOAD_FAST_BORROW_7",
- [_LOAD_FAST_BORROW_LOAD_FAST_BORROW] = "_LOAD_FAST_BORROW_LOAD_FAST_BORROW",
+ [_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_CHECK] = "_LOAD_FAST_CHECK",
- [_LOAD_FAST_LOAD_FAST] = "_LOAD_FAST_LOAD_FAST",
+ [_LOAD_FAST_CHECK_r01] = "_LOAD_FAST_CHECK_r01",
[_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",
+ [_LOAD_GLOBAL_r00] = "_LOAD_GLOBAL_r00",
[_LOAD_GLOBAL_BUILTINS] = "_LOAD_GLOBAL_BUILTINS",
+ [_LOAD_GLOBAL_BUILTINS_r01] = "_LOAD_GLOBAL_BUILTINS_r01",
[_LOAD_GLOBAL_MODULE] = "_LOAD_GLOBAL_MODULE",
+ [_LOAD_GLOBAL_MODULE_r01] = "_LOAD_GLOBAL_MODULE_r01",
[_LOAD_LOCALS] = "_LOAD_LOCALS",
+ [_LOAD_LOCALS_r01] = "_LOAD_LOCALS_r01",
[_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_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_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_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_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_SPECIAL] = "_LOAD_SPECIAL",
+ [_LOAD_SPECIAL_r00] = "_LOAD_SPECIAL_r00",
[_LOAD_SUPER_ATTR_ATTR] = "_LOAD_SUPER_ATTR_ATTR",
+ [_LOAD_SUPER_ATTR_ATTR_r31] = "_LOAD_SUPER_ATTR_ATTR_r31",
[_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_CELL] = "_MAKE_CELL",
+ [_MAKE_CELL_r00] = "_MAKE_CELL_r00",
[_MAKE_FUNCTION] = "_MAKE_FUNCTION",
+ [_MAKE_FUNCTION_r11] = "_MAKE_FUNCTION_r11",
[_MAKE_WARM] = "_MAKE_WARM",
+ [_MAKE_WARM_r00] = "_MAKE_WARM_r00",
+ [_MAKE_WARM_r11] = "_MAKE_WARM_r11",
+ [_MAKE_WARM_r22] = "_MAKE_WARM_r22",
+ [_MAKE_WARM_r33] = "_MAKE_WARM_r33",
[_MAP_ADD] = "_MAP_ADD",
+ [_MAP_ADD_r20] = "_MAP_ADD_r20",
[_MATCH_CLASS] = "_MATCH_CLASS",
+ [_MATCH_CLASS_r31] = "_MATCH_CLASS_r31",
[_MATCH_KEYS] = "_MATCH_KEYS",
+ [_MATCH_KEYS_r23] = "_MATCH_KEYS_r23",
[_MATCH_MAPPING] = "_MATCH_MAPPING",
+ [_MATCH_MAPPING_r02] = "_MATCH_MAPPING_r02",
+ [_MATCH_MAPPING_r12] = "_MATCH_MAPPING_r12",
+ [_MATCH_MAPPING_r23] = "_MATCH_MAPPING_r23",
[_MATCH_SEQUENCE] = "_MATCH_SEQUENCE",
+ [_MATCH_SEQUENCE_r02] = "_MATCH_SEQUENCE_r02",
+ [_MATCH_SEQUENCE_r12] = "_MATCH_SEQUENCE_r12",
+ [_MATCH_SEQUENCE_r23] = "_MATCH_SEQUENCE_r23",
[_MAYBE_EXPAND_METHOD] = "_MAYBE_EXPAND_METHOD",
+ [_MAYBE_EXPAND_METHOD_r00] = "_MAYBE_EXPAND_METHOD_r00",
[_MAYBE_EXPAND_METHOD_KW] = "_MAYBE_EXPAND_METHOD_KW",
+ [_MAYBE_EXPAND_METHOD_KW_r11] = "_MAYBE_EXPAND_METHOD_KW_r11",
[_NOP] = "_NOP",
+ [_NOP_r00] = "_NOP_r00",
+ [_NOP_r11] = "_NOP_r11",
+ [_NOP_r22] = "_NOP_r22",
+ [_NOP_r33] = "_NOP_r33",
[_POP_CALL] = "_POP_CALL",
+ [_POP_CALL_r20] = "_POP_CALL_r20",
[_POP_CALL_LOAD_CONST_INLINE_BORROW] = "_POP_CALL_LOAD_CONST_INLINE_BORROW",
+ [_POP_CALL_LOAD_CONST_INLINE_BORROW_r21] = "_POP_CALL_LOAD_CONST_INLINE_BORROW_r21",
[_POP_CALL_ONE] = "_POP_CALL_ONE",
+ [_POP_CALL_ONE_r30] = "_POP_CALL_ONE_r30",
[_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_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_EXCEPT] = "_POP_EXCEPT",
+ [_POP_EXCEPT_r10] = "_POP_EXCEPT_r10",
[_POP_ITER] = "_POP_ITER",
+ [_POP_ITER_r20] = "_POP_ITER_r20",
[_POP_TOP] = "_POP_TOP",
+ [_POP_TOP_r10] = "_POP_TOP_r10",
[_POP_TOP_FLOAT] = "_POP_TOP_FLOAT",
+ [_POP_TOP_FLOAT_r00] = "_POP_TOP_FLOAT_r00",
+ [_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_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_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",
+ [_POP_TOP_LOAD_CONST_INLINE_BORROW_r11] = "_POP_TOP_LOAD_CONST_INLINE_BORROW_r11",
[_POP_TOP_NOP] = "_POP_TOP_NOP",
+ [_POP_TOP_NOP_r00] = "_POP_TOP_NOP_r00",
+ [_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_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_TWO] = "_POP_TWO",
+ [_POP_TWO_r20] = "_POP_TWO_r20",
[_POP_TWO_LOAD_CONST_INLINE_BORROW] = "_POP_TWO_LOAD_CONST_INLINE_BORROW",
+ [_POP_TWO_LOAD_CONST_INLINE_BORROW_r21] = "_POP_TWO_LOAD_CONST_INLINE_BORROW_r21",
[_PUSH_EXC_INFO] = "_PUSH_EXC_INFO",
+ [_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_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_CONDITIONAL] = "_PUSH_NULL_CONDITIONAL",
+ [_PUSH_NULL_CONDITIONAL_r00] = "_PUSH_NULL_CONDITIONAL_r00",
[_PY_FRAME_GENERAL] = "_PY_FRAME_GENERAL",
+ [_PY_FRAME_GENERAL_r01] = "_PY_FRAME_GENERAL_r01",
[_PY_FRAME_KW] = "_PY_FRAME_KW",
+ [_PY_FRAME_KW_r11] = "_PY_FRAME_KW_r11",
[_REPLACE_WITH_TRUE] = "_REPLACE_WITH_TRUE",
+ [_REPLACE_WITH_TRUE_r11] = "_REPLACE_WITH_TRUE_r11",
[_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",
[_RETURN_GENERATOR] = "_RETURN_GENERATOR",
+ [_RETURN_GENERATOR_r01] = "_RETURN_GENERATOR_r01",
[_RETURN_VALUE] = "_RETURN_VALUE",
+ [_RETURN_VALUE_r11] = "_RETURN_VALUE_r11",
[_SAVE_RETURN_OFFSET] = "_SAVE_RETURN_OFFSET",
+ [_SAVE_RETURN_OFFSET_r00] = "_SAVE_RETURN_OFFSET_r00",
+ [_SAVE_RETURN_OFFSET_r11] = "_SAVE_RETURN_OFFSET_r11",
+ [_SAVE_RETURN_OFFSET_r22] = "_SAVE_RETURN_OFFSET_r22",
+ [_SAVE_RETURN_OFFSET_r33] = "_SAVE_RETURN_OFFSET_r33",
[_SEND_GEN_FRAME] = "_SEND_GEN_FRAME",
+ [_SEND_GEN_FRAME_r22] = "_SEND_GEN_FRAME_r22",
[_SETUP_ANNOTATIONS] = "_SETUP_ANNOTATIONS",
+ [_SETUP_ANNOTATIONS_r00] = "_SETUP_ANNOTATIONS_r00",
[_SET_ADD] = "_SET_ADD",
+ [_SET_ADD_r10] = "_SET_ADD_r10",
[_SET_FUNCTION_ATTRIBUTE] = "_SET_FUNCTION_ATTRIBUTE",
+ [_SET_FUNCTION_ATTRIBUTE_r01] = "_SET_FUNCTION_ATTRIBUTE_r01",
+ [_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_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_UPDATE] = "_SET_UPDATE",
+ [_SET_UPDATE_r10] = "_SET_UPDATE_r10",
+ [_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_r10] = "_SPILL_OR_RELOAD_r10",
+ [_SPILL_OR_RELOAD_r12] = "_SPILL_OR_RELOAD_r12",
+ [_SPILL_OR_RELOAD_r13] = "_SPILL_OR_RELOAD_r13",
+ [_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_r30] = "_SPILL_OR_RELOAD_r30",
+ [_SPILL_OR_RELOAD_r31] = "_SPILL_OR_RELOAD_r31",
+ [_SPILL_OR_RELOAD_r32] = "_SPILL_OR_RELOAD_r32",
[_START_EXECUTOR] = "_START_EXECUTOR",
+ [_START_EXECUTOR_r00] = "_START_EXECUTOR_r00",
[_STORE_ATTR] = "_STORE_ATTR",
+ [_STORE_ATTR_r20] = "_STORE_ATTR_r20",
[_STORE_ATTR_INSTANCE_VALUE] = "_STORE_ATTR_INSTANCE_VALUE",
+ [_STORE_ATTR_INSTANCE_VALUE_r20] = "_STORE_ATTR_INSTANCE_VALUE_r20",
[_STORE_ATTR_SLOT] = "_STORE_ATTR_SLOT",
+ [_STORE_ATTR_SLOT_r20] = "_STORE_ATTR_SLOT_r20",
[_STORE_ATTR_WITH_HINT] = "_STORE_ATTR_WITH_HINT",
+ [_STORE_ATTR_WITH_HINT_r20] = "_STORE_ATTR_WITH_HINT_r20",
[_STORE_DEREF] = "_STORE_DEREF",
+ [_STORE_DEREF_r10] = "_STORE_DEREF_r10",
[_STORE_FAST] = "_STORE_FAST",
+ [_STORE_FAST_r10] = "_STORE_FAST_r10",
[_STORE_FAST_0] = "_STORE_FAST_0",
+ [_STORE_FAST_0_r10] = "_STORE_FAST_0_r10",
[_STORE_FAST_1] = "_STORE_FAST_1",
+ [_STORE_FAST_1_r10] = "_STORE_FAST_1_r10",
[_STORE_FAST_2] = "_STORE_FAST_2",
+ [_STORE_FAST_2_r10] = "_STORE_FAST_2_r10",
[_STORE_FAST_3] = "_STORE_FAST_3",
+ [_STORE_FAST_3_r10] = "_STORE_FAST_3_r10",
[_STORE_FAST_4] = "_STORE_FAST_4",
+ [_STORE_FAST_4_r10] = "_STORE_FAST_4_r10",
[_STORE_FAST_5] = "_STORE_FAST_5",
+ [_STORE_FAST_5_r10] = "_STORE_FAST_5_r10",
[_STORE_FAST_6] = "_STORE_FAST_6",
+ [_STORE_FAST_6_r10] = "_STORE_FAST_6_r10",
[_STORE_FAST_7] = "_STORE_FAST_7",
- [_STORE_FAST_LOAD_FAST] = "_STORE_FAST_LOAD_FAST",
- [_STORE_FAST_STORE_FAST] = "_STORE_FAST_STORE_FAST",
+ [_STORE_FAST_7_r10] = "_STORE_FAST_7_r10",
[_STORE_GLOBAL] = "_STORE_GLOBAL",
+ [_STORE_GLOBAL_r10] = "_STORE_GLOBAL_r10",
[_STORE_NAME] = "_STORE_NAME",
+ [_STORE_NAME_r10] = "_STORE_NAME_r10",
[_STORE_SLICE] = "_STORE_SLICE",
+ [_STORE_SLICE_r30] = "_STORE_SLICE_r30",
[_STORE_SUBSCR] = "_STORE_SUBSCR",
+ [_STORE_SUBSCR_r30] = "_STORE_SUBSCR_r30",
[_STORE_SUBSCR_DICT] = "_STORE_SUBSCR_DICT",
+ [_STORE_SUBSCR_DICT_r30] = "_STORE_SUBSCR_DICT_r30",
[_STORE_SUBSCR_LIST_INT] = "_STORE_SUBSCR_LIST_INT",
+ [_STORE_SUBSCR_LIST_INT_r30] = "_STORE_SUBSCR_LIST_INT_r30",
[_SWAP] = "_SWAP",
+ [_SWAP_r11] = "_SWAP_r11",
[_SWAP_2] = "_SWAP_2",
+ [_SWAP_2_r02] = "_SWAP_2_r02",
+ [_SWAP_2_r12] = "_SWAP_2_r12",
+ [_SWAP_2_r22] = "_SWAP_2_r22",
+ [_SWAP_2_r33] = "_SWAP_2_r33",
[_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",
[_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",
[_TO_BOOL] = "_TO_BOOL",
+ [_TO_BOOL_r11] = "_TO_BOOL_r11",
[_TO_BOOL_BOOL] = "_TO_BOOL_BOOL",
+ [_TO_BOOL_BOOL_r01] = "_TO_BOOL_BOOL_r01",
+ [_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_INT] = "_TO_BOOL_INT",
+ [_TO_BOOL_INT_r11] = "_TO_BOOL_INT_r11",
[_TO_BOOL_LIST] = "_TO_BOOL_LIST",
+ [_TO_BOOL_LIST_r11] = "_TO_BOOL_LIST_r11",
[_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_STR] = "_TO_BOOL_STR",
+ [_TO_BOOL_STR_r11] = "_TO_BOOL_STR_r11",
[_UNARY_INVERT] = "_UNARY_INVERT",
+ [_UNARY_INVERT_r11] = "_UNARY_INVERT_r11",
[_UNARY_NEGATIVE] = "_UNARY_NEGATIVE",
+ [_UNARY_NEGATIVE_r11] = "_UNARY_NEGATIVE_r11",
[_UNARY_NOT] = "_UNARY_NOT",
+ [_UNARY_NOT_r01] = "_UNARY_NOT_r01",
+ [_UNARY_NOT_r11] = "_UNARY_NOT_r11",
+ [_UNARY_NOT_r22] = "_UNARY_NOT_r22",
+ [_UNARY_NOT_r33] = "_UNARY_NOT_r33",
[_UNPACK_EX] = "_UNPACK_EX",
+ [_UNPACK_EX_r10] = "_UNPACK_EX_r10",
[_UNPACK_SEQUENCE] = "_UNPACK_SEQUENCE",
+ [_UNPACK_SEQUENCE_r10] = "_UNPACK_SEQUENCE_r10",
[_UNPACK_SEQUENCE_LIST] = "_UNPACK_SEQUENCE_LIST",
+ [_UNPACK_SEQUENCE_LIST_r10] = "_UNPACK_SEQUENCE_LIST_r10",
[_UNPACK_SEQUENCE_TUPLE] = "_UNPACK_SEQUENCE_TUPLE",
+ [_UNPACK_SEQUENCE_TUPLE_r10] = "_UNPACK_SEQUENCE_TUPLE_r10",
[_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",
[_YIELD_VALUE] = "_YIELD_VALUE",
+ [_YIELD_VALUE_r11] = "_YIELD_VALUE_r11",
};
int _PyUop_num_popped(int opcode, int oparg)
{
return 0;
case _LOAD_FAST_AND_CLEAR:
return 0;
- case _LOAD_FAST_LOAD_FAST:
- return 0;
- case _LOAD_FAST_BORROW_LOAD_FAST_BORROW:
- return 0;
case _LOAD_CONST:
return 0;
case _LOAD_SMALL_INT_0:
return 1;
case _STORE_FAST:
return 1;
- case _STORE_FAST_LOAD_FAST:
- return 1;
- case _STORE_FAST_STORE_FAST:
- return 2;
case _POP_TOP:
return 1;
case _POP_TOP_NOP:
return 0;
case _ERROR_POP_N:
return 0;
+ case _SPILL_OR_RELOAD:
+ return 0;
case _TIER2_RESUME_CHECK:
return 0;
case _COLD_EXIT:
#endif
#define TIER_TWO 2
- case _NOP: {
+ case _NOP_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_PERIODIC: {
+ case _NOP_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _NOP_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _NOP_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
+ _tos_cache2 = _stack_item_2;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_PERIODIC_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = check_periodics(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) {
+ 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_WITH_CACHE());
break;
}
/* _CHECK_PERIODIC_AT_END is not a viable micro-op for tier 2 because it is replaced */
- case _CHECK_PERIODIC_IF_NOT_YIELD_FROM: {
+ case _CHECK_PERIODIC_IF_NOT_YIELD_FROM_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
oparg = CURRENT_OPARG();
if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) {
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = check_periodics(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) {
+ 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_WITH_CACHE());
break;
}
/* _LOAD_BYTECODE is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
- case _RESUME_CHECK: {
+ case _RESUME_CHECK_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ #if defined(__EMSCRIPTEN__)
+ if (_Py_emscripten_signal_clock == 0) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ 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);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ #ifdef Py_GIL_DISABLED
+ if (frame->tlbc_index !=
+ ((_PyThreadStateImpl *)tstate)->tlbc_index) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ #endif
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _RESUME_CHECK_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ #if defined(__EMSCRIPTEN__)
+ if (_Py_emscripten_signal_clock == 0) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ 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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ #ifdef Py_GIL_DISABLED
+ if (frame->tlbc_index !=
+ ((_PyThreadStateImpl *)tstate)->tlbc_index) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ #endif
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _RESUME_CHECK_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ #if defined(__EMSCRIPTEN__)
+ if (_Py_emscripten_signal_clock == 0) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ 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);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ #ifdef Py_GIL_DISABLED
+ if (frame->tlbc_index !=
+ ((_PyThreadStateImpl *)tstate)->tlbc_index) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ #endif
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _RESUME_CHECK_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
#if defined(__EMSCRIPTEN__)
if (_Py_emscripten_signal_clock == 0) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
_Py_emscripten_signal_clock -= Py_EMSCRIPTEN_SIGNAL_HANDLING;
assert((version & _PY_EVAL_EVENTS_MASK) == 0);
if (eval_breaker != version) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
#ifdef Py_GIL_DISABLED
if (frame->tlbc_index !=
((_PyThreadStateImpl *)tstate)->tlbc_index) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
#endif
+ _tos_cache2 = _stack_item_2;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _MONITOR_RESUME is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
- case _LOAD_FAST_CHECK: {
+ case _LOAD_FAST_CHECK_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
oparg = CURRENT_OPARG();
_PyStackRef value_s = GETLOCAL(oparg);
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);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_0: {
+ case _LOAD_FAST_0_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
oparg = 0;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_1: {
+ case _LOAD_FAST_0_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 1;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 0;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_2: {
+ case _LOAD_FAST_0_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 2;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 0;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- 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_WITH_CACHE());
break;
}
- case _LOAD_FAST_3: {
+ case _LOAD_FAST_1_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 3;
+ oparg = 1;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_4: {
+ case _LOAD_FAST_1_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 4;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 1;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_5: {
+ case _LOAD_FAST_1_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 5;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 1;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- 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_WITH_CACHE());
break;
}
- case _LOAD_FAST_6: {
+ case _LOAD_FAST_2_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 6;
+ oparg = 2;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_7: {
+ case _LOAD_FAST_2_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 7;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 2;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST: {
+ case _LOAD_FAST_2_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = CURRENT_OPARG();
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 2;
+ assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
value = PyStackRef_DUP(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- 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_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW_0: {
+ case _LOAD_FAST_3_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 0;
+ oparg = 3;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW_1: {
+ case _LOAD_FAST_3_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 1;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 3;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW_2: {
+ case _LOAD_FAST_3_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 2;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 3;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ 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_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW_3: {
+ case _LOAD_FAST_4_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 3;
+ oparg = 4;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW_4: {
+ case _LOAD_FAST_4_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = 4;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW_5: {
+ case _LOAD_FAST_4_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 5;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 4;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ 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_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW_6: {
+ case _LOAD_FAST_5_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 6;
+ oparg = 5;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW_7: {
+ case _LOAD_FAST_5_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 7;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 5;
assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FAST_BORROW: {
+ case _LOAD_FAST_5_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = CURRENT_OPARG();
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 5;
+ assert(oparg == CURRENT_OPARG());
assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
- value = PyStackRef_Borrow(GETLOCAL(oparg));
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ 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_WITH_CACHE());
break;
}
- case _LOAD_FAST_AND_CLEAR: {
+ case _LOAD_FAST_6_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = CURRENT_OPARG();
- value = GETLOCAL(oparg);
- GETLOCAL(oparg) = PyStackRef_NULL;
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ 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_WITH_CACHE());
break;
}
- case _LOAD_CONST: {
+ case _LOAD_FAST_6_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = CURRENT_OPARG();
- PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg);
- value = PyStackRef_FromPyObjectBorrow(obj);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 6;
+ assert(oparg == CURRENT_OPARG());
+ assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_SMALL_INT_0: {
+ case _LOAD_FAST_6_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 0;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 6;
assert(oparg == CURRENT_OPARG());
- assert(oparg < _PY_NSMALLPOSINTS);
- PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg];
- value = PyStackRef_FromPyObjectBorrow(obj);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(!PyStackRef_IsNull(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_WITH_CACHE());
break;
}
- case _LOAD_SMALL_INT_1: {
+ case _LOAD_FAST_7_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 1;
+ oparg = 7;
assert(oparg == CURRENT_OPARG());
- assert(oparg < _PY_NSMALLPOSINTS);
- PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg];
- value = PyStackRef_FromPyObjectBorrow(obj);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_SMALL_INT_2: {
+ case _LOAD_FAST_7_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 2;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 7;
assert(oparg == CURRENT_OPARG());
- assert(oparg < _PY_NSMALLPOSINTS);
- PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg];
- value = PyStackRef_FromPyObjectBorrow(obj);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_SMALL_INT_3: {
+ case _LOAD_FAST_7_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 3;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 7;
assert(oparg == CURRENT_OPARG());
- assert(oparg < _PY_NSMALLPOSINTS);
- PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg];
- value = PyStackRef_FromPyObjectBorrow(obj);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(!PyStackRef_IsNull(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_WITH_CACHE());
break;
}
- case _LOAD_SMALL_INT: {
+ case _LOAD_FAST_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
oparg = CURRENT_OPARG();
- assert(oparg < _PY_NSMALLPOSINTS);
- PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg];
- value = PyStackRef_FromPyObjectBorrow(obj);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_FAST_0: {
+ case _LOAD_FAST_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 0;
- assert(oparg == CURRENT_OPARG());
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = CURRENT_OPARG();
+ assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
+ value = PyStackRef_DUP(GETLOCAL(oparg));
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_FAST_1: {
+ case _LOAD_FAST_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 1;
- assert(oparg == CURRENT_OPARG());
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = CURRENT_OPARG();
+ assert(!PyStackRef_IsNull(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_WITH_CACHE());
break;
}
- case _STORE_FAST_2: {
+ case _LOAD_FAST_BORROW_0_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 2;
+ oparg = 0;
assert(oparg == CURRENT_OPARG());
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
+ value = PyStackRef_Borrow(GETLOCAL(oparg));
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_FAST_3: {
+ case _LOAD_FAST_BORROW_0_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 3;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 0;
assert(oparg == CURRENT_OPARG());
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ 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_WITH_CACHE());
break;
}
- case _STORE_FAST_4: {
+ case _LOAD_FAST_BORROW_0_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 4;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 0;
assert(oparg == CURRENT_OPARG());
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ 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_WITH_CACHE());
break;
}
- case _STORE_FAST_5: {
+ case _LOAD_FAST_BORROW_1_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 5;
+ oparg = 1;
assert(oparg == CURRENT_OPARG());
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ assert(!PyStackRef_IsNull(GETLOCAL(oparg)));
+ value = PyStackRef_Borrow(GETLOCAL(oparg));
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_FAST_6: {
+ case _LOAD_FAST_BORROW_1_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 6;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 1;
assert(oparg == CURRENT_OPARG());
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ 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_WITH_CACHE());
break;
}
- case _STORE_FAST_7: {
+ case _LOAD_FAST_BORROW_1_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = 7;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 1;
assert(oparg == CURRENT_OPARG());
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ 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_WITH_CACHE());
break;
}
- case _STORE_FAST: {
+ case _LOAD_FAST_BORROW_2_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- oparg = CURRENT_OPARG();
- value = stack_pointer[-1];
- _PyStackRef tmp = GETLOCAL(oparg);
- GETLOCAL(oparg) = value;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ 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_WITH_CACHE());
break;
}
- case _POP_TOP: {
+ case _LOAD_FAST_BORROW_2_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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_WITH_CACHE());
break;
}
- case _POP_TOP_NOP: {
+ case _LOAD_FAST_BORROW_2_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- assert(PyStackRef_IsNull(value) || (!PyStackRef_RefcountOnObject(value)) ||
- _Py_IsImmortal((PyStackRef_AsPyObjectBorrow(value))));
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ 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_WITH_CACHE());
break;
}
- case _POP_TOP_INT: {
+ case _LOAD_FAST_BORROW_3_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- assert(PyLong_CheckExact(PyStackRef_AsPyObjectBorrow(value)));
- PyStackRef_CLOSE_SPECIALIZED(value, _PyLong_ExactDealloc);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ 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_WITH_CACHE());
break;
}
- case _POP_TOP_FLOAT: {
+ case _LOAD_FAST_BORROW_3_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- assert(PyFloat_CheckExact(PyStackRef_AsPyObjectBorrow(value)));
- PyStackRef_CLOSE_SPECIALIZED(value, _PyFloat_ExactDealloc);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 3;
+ 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_WITH_CACHE());
break;
}
- case _POP_TOP_UNICODE: {
+ case _LOAD_FAST_BORROW_3_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(value)));
- PyStackRef_CLOSE_SPECIALIZED(value, _PyUnicode_ExactDealloc);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 3;
+ 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_WITH_CACHE());
break;
}
- case _POP_TWO: {
- _PyStackRef tos;
- _PyStackRef nos;
- tos = stack_pointer[-1];
- nos = stack_pointer[-2];
- 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);
+ case _LOAD_FAST_BORROW_4_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ oparg = 4;
+ 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_WITH_CACHE());
break;
}
- case _PUSH_NULL: {
- _PyStackRef res;
- res = PyStackRef_NULL;
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ case _LOAD_FAST_BORROW_4_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 4;
+ 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_WITH_CACHE());
break;
}
- case _END_FOR: {
+ case _LOAD_FAST_BORROW_4_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 4;
+ 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_WITH_CACHE());
break;
}
- case _POP_ITER: {
- _PyStackRef index_or_null;
- _PyStackRef iter;
- index_or_null = stack_pointer[-1];
- iter = stack_pointer[-2];
- (void)index_or_null;
- stack_pointer += -2;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_CLOSE(iter);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ case _LOAD_FAST_BORROW_5_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _END_SEND: {
+ case _LOAD_FAST_BORROW_5_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef receiver;
- _PyStackRef val;
- value = stack_pointer[-1];
- receiver = stack_pointer[-2];
- val = value;
- stack_pointer[-2] = val;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_CLOSE(receiver);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 5;
+ 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_WITH_CACHE());
break;
}
- case _UNARY_NEGATIVE: {
+ case _LOAD_FAST_BORROW_5_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- value = stack_pointer[-1];
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyObject *res_o = PyNumber_Negative(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) {
- JUMP_TO_ERROR();
- }
- res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 5;
+ 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_WITH_CACHE());
break;
}
- case _UNARY_NOT: {
+ case _LOAD_FAST_BORROW_6_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- value = stack_pointer[-1];
- assert(PyStackRef_BoolCheck(value));
- res = PyStackRef_IsFalse(value)
- ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-1] = res;
+ oparg = 6;
+ 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_WITH_CACHE());
break;
}
- case _TO_BOOL: {
+ case _LOAD_FAST_BORROW_6_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- value = stack_pointer[-1];
- _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) {
- JUMP_TO_ERROR();
- }
- res = err ? PyStackRef_True : PyStackRef_False;
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 6;
+ 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_WITH_CACHE());
break;
}
- case _TO_BOOL_BOOL: {
+ case _LOAD_FAST_BORROW_6_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- if (!PyStackRef_BoolCheck(value)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
- STAT_INC(TO_BOOL, hit);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 6;
+ 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_WITH_CACHE());
break;
}
- case _TO_BOOL_INT: {
+ case _LOAD_FAST_BORROW_7_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- value = stack_pointer[-1];
- PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
- if (!PyLong_CheckExact(value_o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
- STAT_INC(TO_BOOL, hit);
- if (_PyLong_IsZero((PyLongObject *)value_o)) {
- assert(_Py_IsImmortal(value_o));
- res = PyStackRef_False;
- }
- else {
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- res = PyStackRef_True;
- stack_pointer += 1;
- }
- stack_pointer[-1] = res;
+ 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_WITH_CACHE());
break;
}
- case _GUARD_NOS_LIST: {
- _PyStackRef nos;
- nos = stack_pointer[-2];
- PyObject *o = PyStackRef_AsPyObjectBorrow(nos);
- if (!PyList_CheckExact(o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
+ case _LOAD_FAST_BORROW_7_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 7;
+ 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_WITH_CACHE());
break;
}
- case _GUARD_TOS_LIST: {
- _PyStackRef tos;
- tos = stack_pointer[-1];
- PyObject *o = PyStackRef_AsPyObjectBorrow(tos);
- if (!PyList_CheckExact(o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
+ case _LOAD_FAST_BORROW_7_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 7;
+ 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_WITH_CACHE());
break;
}
- case _GUARD_TOS_SLICE: {
- _PyStackRef tos;
- tos = stack_pointer[-1];
- PyObject *o = PyStackRef_AsPyObjectBorrow(tos);
- if (!PySlice_Check(o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
+ case _LOAD_FAST_BORROW_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ 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_WITH_CACHE());
break;
}
- case _TO_BOOL_LIST: {
+ case _LOAD_FAST_BORROW_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- 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;
- _PyFrame_SetStackPointer(frame, stack_pointer);
- _PyStackRef tmp = value;
- value = res;
- stack_pointer[-1] = value;
- PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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_WITH_CACHE());
break;
}
- case _TO_BOOL_NONE: {
+ case _LOAD_FAST_BORROW_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- value = stack_pointer[-1];
- if (!PyStackRef_IsNone(value)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
- STAT_INC(TO_BOOL, hit);
- res = PyStackRef_False;
- stack_pointer[-1] = res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ 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_WITH_CACHE());
break;
}
- case _GUARD_NOS_UNICODE: {
- _PyStackRef nos;
- nos = stack_pointer[-2];
- PyObject *o = PyStackRef_AsPyObjectBorrow(nos);
- if (!PyUnicode_CheckExact(o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
+ case _LOAD_FAST_AND_CLEAR_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _GUARD_TOS_UNICODE: {
+ case _LOAD_FAST_AND_CLEAR_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
- if (!PyUnicode_CheckExact(value_o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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_WITH_CACHE());
break;
}
- case _TO_BOOL_STR: {
+ case _LOAD_FAST_AND_CLEAR_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- value = stack_pointer[-1];
- STAT_INC(TO_BOOL, hit);
- PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
- if (value_o == &_Py_STR(empty)) {
- assert(_Py_IsImmortal(value_o));
- res = PyStackRef_False;
- }
- else {
- assert(Py_SIZE(value_o));
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- res = PyStackRef_True;
- stack_pointer += 1;
- }
- stack_pointer[-1] = res;
+ _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;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _REPLACE_WITH_TRUE: {
+ case _LOAD_CONST_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- value = stack_pointer[-1];
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- res = PyStackRef_True;
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ 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_WITH_CACHE());
break;
}
- case _UNARY_INVERT: {
+ case _LOAD_CONST_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- _PyStackRef res;
- value = stack_pointer[-1];
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyObject *res_o = PyNumber_Invert(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) {
- JUMP_TO_ERROR();
- }
- res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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_WITH_CACHE());
break;
}
- case _GUARD_NOS_INT: {
- _PyStackRef left;
- left = stack_pointer[-2];
- PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
- if (!_PyLong_CheckExactAndCompact(left_o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
+ case _LOAD_CONST_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ _tos_cache2 = value;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_TOS_INT: {
+ case _LOAD_SMALL_INT_0_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- value = stack_pointer[-1];
- PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
- if (!_PyLong_CheckExactAndCompact(value_o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
+ 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_WITH_CACHE());
break;
}
- case _GUARD_NOS_OVERFLOWED: {
- _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);
- JUMP_TO_JUMP_TARGET();
- }
+ case _LOAD_SMALL_INT_0_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 0;
+ 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_WITH_CACHE());
break;
}
- case _GUARD_TOS_OVERFLOWED: {
+ case _LOAD_SMALL_INT_0_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
- JUMP_TO_JUMP_TARGET();
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = 0;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_1_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_1_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_1_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_2_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_2_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_2_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ 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(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_3_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_3_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_3_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ 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(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_SMALL_INT_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_0_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 0;
+ assert(oparg == CURRENT_OPARG());
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_1_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 1;
+ assert(oparg == CURRENT_OPARG());
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_2_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 2;
+ assert(oparg == CURRENT_OPARG());
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_3_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 3;
+ assert(oparg == CURRENT_OPARG());
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_4_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 4;
+ assert(oparg == CURRENT_OPARG());
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_5_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 5;
+ assert(oparg == CURRENT_OPARG());
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_6_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 6;
+ assert(oparg == CURRENT_OPARG());
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_7_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = 7;
+ assert(oparg == CURRENT_OPARG());
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _STORE_FAST_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = CURRENT_OPARG();
+ value = _stack_item_0;
+ _PyStackRef tmp = GETLOCAL(oparg);
+ GETLOCAL(oparg) = value;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_NOP_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_NOP_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_NOP_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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))));
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_NOP_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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))));
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_INT_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_INT_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_INT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_INT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_FLOAT_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_FLOAT_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_FLOAT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_FLOAT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_UNICODE_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_UNICODE_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_UNICODE_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_UNICODE_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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(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_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TWO_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef tos;
+ _PyStackRef nos;
+ _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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _PUSH_NULL_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef res;
+ res = PyStackRef_NULL;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _PUSH_NULL_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ res = PyStackRef_NULL;
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _PUSH_NULL_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ res = PyStackRef_NULL;
+ _tos_cache2 = res;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _END_FOR_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _POP_ITER_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef index_or_null;
+ _PyStackRef iter;
+ _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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _END_SEND_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef receiver;
+ _PyStackRef val;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _UNARY_NEGATIVE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _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);
+ 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;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _UNARY_NOT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ value = stack_pointer[-1];
+ assert(PyStackRef_BoolCheck(value));
+ res = PyStackRef_IsFalse(value)
+ ? PyStackRef_True : PyStackRef_False;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _UNARY_NOT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ value = _stack_item_0;
+ assert(PyStackRef_BoolCheck(value));
+ res = PyStackRef_IsFalse(value)
+ ? PyStackRef_True : PyStackRef_False;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _UNARY_NOT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _UNARY_NOT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_BOOL_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ 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;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_BOOL_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ value = _stack_item_0;
+ if (!PyStackRef_BoolCheck(value)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ STAT_INC(TO_BOOL, hit);
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_BOOL_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ value = _stack_item_1;
+ if (!PyStackRef_BoolCheck(value)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ STAT_INC(TO_BOOL, hit);
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_BOOL_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ if (!PyStackRef_BoolCheck(value)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
+ JUMP_TO_JUMP_TARGET();
+ }
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_INT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ value = _stack_item_0;
+ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
+ if (!PyLong_CheckExact(value_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ STAT_INC(TO_BOOL, hit);
+ if (_PyLong_IsZero((PyLongObject *)value_o)) {
+ assert(_Py_IsImmortal(value_o));
+ res = PyStackRef_False;
+ }
+ else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ res = PyStackRef_True;
+ }
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_LIST_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_LIST_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef nos;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ nos = stack_pointer[-1];
+ PyObject *o = PyStackRef_AsPyObjectBorrow(nos);
+ if (!PyList_CheckExact(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_LIST_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PyList_CheckExact(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_LIST_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PyList_CheckExact(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_LIST_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_LIST_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef tos;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ tos = _stack_item_0;
+ PyObject *o = PyStackRef_AsPyObjectBorrow(tos);
+ if (!PyList_CheckExact(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = tos;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_LIST_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PyList_CheckExact(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_LIST_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PyList_CheckExact(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_SLICE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_SLICE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = tos;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_SLICE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PySlice_Check(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_SLICE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PySlice_Check(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_LIST_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ 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;
+ stack_pointer[0] = value;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = value;
+ value = res;
+ stack_pointer[-1] = value;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _tos_cache0 = res;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_NONE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_NONE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ value = _stack_item_0;
+ if (!PyStackRef_IsNone(value)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_NONE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _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);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_NONE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _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);
+ SET_CURRENT_CACHED_VALUES(3);
+ JUMP_TO_JUMP_TARGET();
+ }
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_UNICODE_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_UNICODE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_UNICODE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PyUnicode_CheckExact(o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_UNICODE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_UNICODE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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 += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_UNICODE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ value = _stack_item_0;
+ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
+ if (!PyUnicode_CheckExact(value_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_UNICODE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PyUnicode_CheckExact(value_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_UNICODE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
+ if (!PyUnicode_CheckExact(value_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _TO_BOOL_STR_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ value = _stack_item_0;
+ STAT_INC(TO_BOOL, hit);
+ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
+ if (value_o == &_Py_STR(empty)) {
+ assert(_Py_IsImmortal(value_o));
+ res = PyStackRef_False;
+ }
+ else {
+ assert(Py_SIZE(value_o));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ res = PyStackRef_True;
+ }
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _REPLACE_WITH_TRUE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ value = _stack_item_0;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ res = PyStackRef_True;
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _UNARY_INVERT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef res;
+ _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);
+ 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;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_INT_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_INT_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_INT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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 (!_PyLong_CheckExactAndCompact(left_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_INT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef left;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_INT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_INT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_INT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_INT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
+ if (!_PyLong_CheckExactAndCompact(value_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_OVERFLOWED_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_OVERFLOWED_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_OVERFLOWED_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef left;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_OVERFLOWED_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef left;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_OVERFLOWED_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_OVERFLOWED_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_OVERFLOWED_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_OVERFLOWED_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ 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(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_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_MULTIPLY_INT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ 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();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_MULTIPLY_INT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_MULTIPLY_INT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_MULTIPLY_INT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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);
+ SET_CURRENT_CACHED_VALUES(3);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_INT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ 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();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_INT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_INT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_INT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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_Add((PyLongObject *)left_o, (PyLongObject *)right_o);
+ if (PyStackRef_IsNull(res)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_INT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ 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();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_INT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_INT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_INT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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);
+ SET_CURRENT_CACHED_VALUES(3);
+ JUMP_TO_JUMP_TARGET();
+ }
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_FLOAT_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_FLOAT_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef left;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_FLOAT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_FLOAT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef left;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_FLOAT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_FLOAT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_FLOAT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 (!PyFloat_CheckExact(value_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_FLOAT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
+ if (!PyFloat_CheckExact(value_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_MULTIPLY_FLOAT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ 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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[-2] = res;
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_MULTIPLY_FLOAT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[-1] = res;
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_MULTIPLY_FLOAT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_MULTIPLY_FLOAT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[0] = _stack_item_0;
+ stack_pointer[1] = res;
+ stack_pointer += 2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_FLOAT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ 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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[-2] = res;
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_FLOAT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[-1] = res;
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_FLOAT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_FLOAT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[0] = _stack_item_0;
+ stack_pointer[1] = res;
+ stack_pointer += 2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_FLOAT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ 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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[-2] = res;
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_FLOAT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[-1] = res;
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_FLOAT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_FLOAT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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 = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ if (PyStackRef_IsNull(res)) {
+ stack_pointer[0] = _stack_item_0;
+ stack_pointer[1] = res;
+ stack_pointer += 2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
}
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_MULTIPLY_INT: {
+ case _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
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));
+ assert(PyFloat_CheckExact(left_o));
+ assert(PyFloat_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
- res = _PyCompactLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);
+ double dres =
+ ((PyFloatObject *)left_o)->ob_fval *
+ ((PyFloatObject *)right_o)->ob_fval;
+ res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
+ stack_pointer[-2] = res;
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
}
- PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
- PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_ADD_INT: {
+ case _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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));
+ assert(PyFloat_CheckExact(left_o));
+ assert(PyFloat_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
- res = _PyCompactLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);
+ double dres =
+ ((PyFloatObject *)left_o)->ob_fval *
+ ((PyFloatObject *)right_o)->ob_fval;
+ res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
+ stack_pointer[-1] = res;
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
}
- PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
- PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- stack_pointer[-2] = res;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBTRACT_INT: {
+ case _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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));
+ assert(PyFloat_CheckExact(left_o));
+ assert(PyFloat_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
- res = _PyCompactLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
+ double dres =
+ ((PyFloatObject *)left_o)->ob_fval *
+ ((PyFloatObject *)right_o)->ob_fval;
+ res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
}
- PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
- PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- stack_pointer[-2] = res;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_NOS_FLOAT: {
+ case _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
_PyStackRef left;
- left = stack_pointer[-2];
+ _PyStackRef res;
+ _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);
- if (!PyFloat_CheckExact(left_o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
- }
- break;
- }
-
- case _GUARD_TOS_FLOAT: {
- _PyStackRef value;
- value = stack_pointer[-1];
- PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
- if (!PyFloat_CheckExact(value_o)) {
- UOP_STAT_INC(uopcode, miss);
- JUMP_TO_JUMP_TARGET();
+ 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] = res;
+ stack_pointer += 2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
}
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_MULTIPLY_FLOAT: {
+ case _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
assert(PyFloat_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
double dres =
- ((PyFloatObject *)left_o)->ob_fval *
+ ((PyFloatObject *)left_o)->ob_fval +
((PyFloatObject *)right_o)->ob_fval;
- res = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
stack_pointer[-2] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_ADD_FLOAT: {
+ case _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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));
double dres =
((PyFloatObject *)left_o)->ob_fval +
((PyFloatObject *)right_o)->ob_fval;
- res = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
- stack_pointer[-2] = res;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ stack_pointer[-1] = res;
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- stack_pointer[-2] = res;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBTRACT_FLOAT: {
+ case _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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 *)left_o)->ob_fval +
((PyFloatObject *)right_o)->ob_fval;
- res = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
+ res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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] = res;
+ stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- stack_pointer[-2] = res;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_MULTIPLY_FLOAT__NO_DECREF_INPUTS: {
+ case _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
assert(PyFloat_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
double dres =
- ((PyFloatObject *)left_o)->ob_fval *
+ ((PyFloatObject *)left_o)->ob_fval -
((PyFloatObject *)right_o)->ob_fval;
res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
stack_pointer[-2] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_ADD_FLOAT__NO_DECREF_INPUTS: {
+ case _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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 *)left_o)->ob_fval -
((PyFloatObject *)right_o)->ob_fval;
res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
- stack_pointer[-2] = res;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ stack_pointer[-1] = res;
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- stack_pointer[-2] = res;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS: {
+ case _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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));
((PyFloatObject *)right_o)->ob_fval;
res = PyStackRef_FromPyObjectSteal(PyFloat_FromDouble(dres));
if (PyStackRef_IsNull(res)) {
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBTRACT_FLOAT__NO_DECREF_INPUTS_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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] = res;
+ stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- stack_pointer[-2] = res;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_ADD_UNICODE: {
+ case _BINARY_OP_ADD_UNICODE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
if (res_o == NULL) {
stack_pointer += -2;
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(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_UNICODE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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);
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
+ if (res_o == NULL) {
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_INPLACE_ADD_UNICODE: {
+ case _BINARY_OP_ADD_UNICODE_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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);
+ 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);
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
+ if (res_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ res = PyStackRef_FromPyObjectSteal(res_o);
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_ADD_UNICODE_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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);
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
+ if (res_o == NULL) {
+ stack_pointer[0] = _stack_item_0;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_ERROR();
+ }
+ res = PyStackRef_FromPyObjectSteal(res_o);
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_INPLACE_ADD_UNICODE_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 *left_o = PyStackRef_AsPyObjectBorrow(left);
assert(PyUnicode_CheckExact(left_o));
assert(PyUnicode_CheckExact(PyStackRef_AsPyObjectBorrow(right)));
assert(PyUnicode_CheckExact(left_o));
if (PyStackRef_AsPyObjectBorrow(*target_local) != left_o) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(BINARY_OP, hit);
PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);
PyObject *right_o = PyStackRef_AsPyObjectSteal(right);
- stack_pointer += -2;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyUnicode_Append(&temp, right_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(right_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(*target_local)) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
#if TIER_ONE
assert(next_instr->op.code == STORE_FAST);
SKIP_OVER(1);
#endif
+ _tos_cache0 = PyStackRef_ZERO_BITS;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_BINARY_OP_EXTEND: {
+ case _GUARD_BINARY_OP_EXTEND_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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();
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);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
+ _tos_cache1 = right;
+ _tos_cache0 = left;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_EXTEND: {
+ case _BINARY_OP_EXTEND_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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();
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);
_PyStackRef tmp = right;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_SLICE: {
+ case _BINARY_SLICE_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef stop;
_PyStackRef start;
_PyStackRef container;
_PyStackRef res;
- stop = stack_pointer[-1];
- start = stack_pointer[-2];
- container = stack_pointer[-3];
+ _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;
+ 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));
PyStackRef_CLOSE(container);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_SLICE: {
+ case _STORE_SLICE_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef stop;
_PyStackRef start;
_PyStackRef container;
_PyStackRef v;
- stop = stack_pointer[-1];
- start = stack_pointer[-2];
- container = stack_pointer[-3];
- v = stack_pointer[-4];
+ _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 += -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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBSCR_LIST_INT: {
+ case _BINARY_OP_SUBSCR_LIST_INT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub_st;
_PyStackRef list_st;
_PyStackRef res;
- sub_st = stack_pointer[-1];
- list_st = stack_pointer[-2];
+ _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);
+ 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);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(BINARY_OP, hit);
#else
if (index >= PyList_GET_SIZE(list)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
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);
_PyFrame_SetStackPointer(frame, stack_pointer);
stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _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_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBSCR_LIST_SLICE: {
+ case _BINARY_OP_SUBSCR_LIST_SLICE_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub_st;
_PyStackRef list_st;
_PyStackRef res;
- sub_st = stack_pointer[-1];
- list_st = stack_pointer[-2];
+ _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);
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);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBSCR_STR_INT: {
+ case _BINARY_OP_SUBSCR_STR_INT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub_st;
_PyStackRef str_st;
_PyStackRef res;
- sub_st = stack_pointer[-1];
- str_st = stack_pointer[-2];
+ _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);
+ 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);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
if (!PyUnicode_IS_COMPACT_ASCII(str)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
uint8_t c = PyUnicode_1BYTE_DATA(str)[index];
STAT_INC(BINARY_OP, hit);
PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c];
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
- stack_pointer += -2;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(str_st);
stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_FromPyObjectBorrow(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_NOS_TUPLE: {
+ case _GUARD_NOS_TUPLE_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_TUPLE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_TUPLE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_TUPLE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- case _GUARD_TOS_TUPLE: {
+ case _GUARD_TOS_TUPLE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_TUPLE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = tos;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_TUPLE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_TUPLE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBSCR_TUPLE_INT: {
+ case _BINARY_OP_SUBSCR_TUPLE_INT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub_st;
_PyStackRef tuple_st;
_PyStackRef res;
- sub_st = stack_pointer[-1];
- tuple_st = stack_pointer[-2];
+ _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);
+ 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);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(BINARY_OP, hit);
assert(res_o != NULL);
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
res = PyStackRef_FromPyObjectNew(res_o);
- stack_pointer += -1;
+ stack_pointer[0] = tuple_st;
+ stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyStackRef tmp = tuple_st;
stack_pointer[-1] = tuple_st;
PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _tos_cache0 = res;
+ _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_WITH_CACHE());
break;
}
- case _GUARD_NOS_DICT: {
+ case _GUARD_NOS_DICT_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_DICT_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_DICT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_DICT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- case _GUARD_TOS_DICT: {
+ case _GUARD_TOS_DICT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_DICT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = tos;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_DICT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_DICT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBSCR_DICT: {
+ case _BINARY_OP_SUBSCR_DICT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub_st;
_PyStackRef dict_st;
_PyStackRef res;
- sub_st = stack_pointer[-1];
- dict_st = stack_pointer[-2];
+ _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(PyDict_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);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (rc <= 0) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBSCR_CHECK_FUNC: {
+ case _BINARY_OP_SUBSCR_CHECK_FUNC_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef container;
_PyStackRef getitem;
- container = stack_pointer[-2];
+ _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);
+ 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);
+ 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);
+ 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);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
getitem = PyStackRef_FromPyObjectNew(getitem_o);
STAT_INC(BINARY_OP, hit);
- stack_pointer[0] = getitem;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache2 = getitem;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = container;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP_SUBSCR_INIT_CALL: {
+ case _BINARY_OP_SUBSCR_INIT_CALL_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef getitem;
_PyStackRef sub;
_PyStackRef container;
pushed_frame->localsplus[1] = sub;
frame->return_offset = 6u ;
new_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[-3] = new_frame;
+ _tos_cache0 = new_frame;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -3;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBSCR_INIT_CALL_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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];
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBSCR_INIT_CALL_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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];
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _BINARY_OP_SUBSCR_INIT_CALL_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ _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_WITH_CACHE());
break;
}
- case _LIST_APPEND: {
+ case _LIST_APPEND_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef v;
_PyStackRef list;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- v = stack_pointer[-1];
- list = stack_pointer[-2 - (oparg-1)];
+ v = _stack_item_0;
+ list = stack_pointer[-1 - (oparg-1)];
int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
PyStackRef_AsPyObjectSteal(v));
if (err < 0) {
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _SET_ADD: {
+ case _SET_ADD_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef v;
_PyStackRef set;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- v = stack_pointer[-1];
- set = stack_pointer[-2 - (oparg-1)];
+ 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));
if (err) {
stack_pointer += -1;
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 += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_SUBSCR: {
+ case _STORE_SUBSCR_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub;
_PyStackRef container;
_PyStackRef v;
- sub = stack_pointer[-1];
- container = stack_pointer[-2];
- v = stack_pointer[-3];
+ _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;
stack_pointer += -3;
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_WITH_CACHE());
break;
}
- case _STORE_SUBSCR_LIST_INT: {
+ case _STORE_SUBSCR_LIST_INT_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub_st;
_PyStackRef list_st;
_PyStackRef value;
- sub_st = stack_pointer[-1];
- list_st = stack_pointer[-2];
- value = stack_pointer[-3];
+ _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);
+ 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);
+ 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);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
}
assert(old_value != NULL);
UNLOCK_OBJECT(list);
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
- stack_pointer += -3;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(list_st);
Py_DECREF(old_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_SUBSCR_DICT: {
+ case _STORE_SUBSCR_DICT_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub;
_PyStackRef dict_st;
_PyStackRef value;
- sub = stack_pointer[-1];
- dict_st = stack_pointer[-2];
- value = stack_pointer[-3];
+ _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_CLOSE(dict_st);
stack_pointer = _PyFrame_GetStackPointer(frame);
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_WITH_CACHE());
break;
}
- case _DELETE_SUBSCR: {
+ case _DELETE_SUBSCR_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef sub;
_PyStackRef container;
- sub = stack_pointer[-1];
- container = stack_pointer[-2];
+ _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));
stack_pointer += -2;
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_WITH_CACHE());
break;
}
- case _CALL_INTRINSIC_1: {
+ case _CALL_INTRINSIC_1_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- value = stack_pointer[-1];
+ 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);
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);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_INTRINSIC_2: {
+ case _CALL_INTRINSIC_2_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_pointer[-1];
- value2_st = stack_pointer[-2];
+ 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;
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);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _RETURN_VALUE: {
+ case _RETURN_VALUE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef retval;
_PyStackRef res;
- retval = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ retval = _stack_item_0;
assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
_PyStackRef temp = PyStackRef_MakeHeapSafe(retval);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(STACK_LEVEL() == 0);
_Py_LeaveRecursiveCallPy(tstate);
LOAD_IP(frame->return_offset);
res = temp;
LLTRACE_RESUME_FRAME();
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GET_AITER: {
+ case _GET_AITER_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef obj;
_PyStackRef iter;
- obj = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ obj = _stack_item_0;
unaryfunc getter = NULL;
PyObject *obj_o = PyStackRef_AsPyObjectBorrow(obj);
PyObject *iter_o;
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 "
_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);
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_name);
Py_DECREF(iter_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- stack_pointer[0] = iter;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = iter;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GET_ANEXT: {
+ case _GET_ANEXT_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef aiter;
_PyStackRef awaitable;
- aiter = stack_pointer[-1];
+ _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);
- stack_pointer[0] = awaitable;
- stack_pointer += 1;
+ _tos_cache1 = awaitable;
+ _tos_cache0 = aiter;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GET_AWAITABLE: {
+ case _GET_AWAITABLE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef iterable;
_PyStackRef iter;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- iterable = stack_pointer[-1];
+ 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);
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);
- stack_pointer[0] = iter;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = iter;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _SEND is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
- case _SEND_GEN_FRAME: {
+ case _SEND_GEN_FRAME_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_pointer[-1];
- receiver = stack_pointer[-2];
+ 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);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
if (gen->gi_frame_state >= FRAME_EXECUTING) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(SEND, hit);
frame->return_offset = (uint16_t)( 2u + oparg);
pushed_frame->previous = frame;
gen_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[-1] = gen_frame;
+ _tos_cache1 = gen_frame;
+ _tos_cache0 = receiver;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _YIELD_VALUE: {
+ case _YIELD_VALUE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef retval;
_PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- retval = stack_pointer[-1];
+ retval = _stack_item_0;
assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
frame->instr_ptr++;
PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame);
assert(oparg == 0 || oparg == 1);
gen->gi_frame_state = FRAME_SUSPENDED + oparg;
_PyStackRef temp = retval;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
value = PyStackRef_MakeHeapSafe(temp);
LLTRACE_RESUME_FRAME();
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _POP_EXCEPT: {
+ case _POP_EXCEPT_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef exc_value;
- exc_value = stack_pointer[-1];
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_COMMON_CONSTANT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _LOAD_COMMON_CONSTANT: {
+ case _LOAD_COMMON_CONSTANT_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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]);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_COMMON_CONSTANT_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _LOAD_BUILD_CLASS: {
+ case _LOAD_BUILD_CLASS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef bc;
PyObject *bc_o;
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (bc_o == NULL) {
_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);
- stack_pointer[0] = bc;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = bc;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_NAME: {
+ case _STORE_NAME_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef v;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- v = stack_pointer[-1];
+ 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);
_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);
PyStackRef_CLOSE(v);
stack_pointer = _PyFrame_GetStackPointer(frame);
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_WITH_CACHE());
break;
}
- case _DELETE_NAME: {
+ case _DELETE_NAME_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
oparg = CURRENT_OPARG();
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
PyObject *ns = LOCALS();
_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);
NAME_ERROR_MSG,
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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _UNPACK_SEQUENCE: {
+ case _UNPACK_SEQUENCE_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef seq;
_PyStackRef *top;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- seq = stack_pointer[-1];
- top = &stack_pointer[-1 + oparg];
+ seq = _stack_item_0;
+ top = &stack_pointer[oparg];
PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_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();
}
+ _tos_cache0 = PyStackRef_ZERO_BITS;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(0);
stack_pointer += oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _UNPACK_SEQUENCE_TWO_TUPLE: {
+ case _UNPACK_SEQUENCE_TWO_TUPLE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef seq;
_PyStackRef val1;
_PyStackRef val0;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- seq = stack_pointer[-1];
+ 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);
+ 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[-1] = val1;
- stack_pointer[0] = val0;
- stack_pointer += 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;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _UNPACK_SEQUENCE_TUPLE: {
+ case _UNPACK_SEQUENCE_TUPLE_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef seq;
_PyStackRef *values;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- seq = stack_pointer[-1];
- values = &stack_pointer[-1];
+ 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);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(UNPACK_SEQUENCE, hit);
for (int i = oparg; --i >= 0; ) {
*values++ = PyStackRef_FromPyObjectNew(items[i]);
}
- stack_pointer += -1 + oparg;
+ 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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _UNPACK_SEQUENCE_LIST: {
+ case _UNPACK_SEQUENCE_LIST_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef seq;
_PyStackRef *values;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- seq = stack_pointer[-1];
- values = &stack_pointer[-1];
+ 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);
+ 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);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
}
*values++ = PyStackRef_FromPyObjectNew(items[i]);
}
UNLOCK_OBJECT(seq_o);
- stack_pointer += -1 + oparg;
+ 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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _UNPACK_EX: {
+ case _UNPACK_EX_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef seq;
_PyStackRef *top;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- seq = stack_pointer[-1];
- top = &stack_pointer[(oparg & 0xFF) + (oparg >> 8)];
+ seq = _stack_item_0;
+ top = &stack_pointer[1 + (oparg & 0xFF) + (oparg >> 8)];
PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_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();
}
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_ATTR: {
+ case _STORE_ATTR_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef v;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
- v = stack_pointer[-2];
+ 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));
stack_pointer += -2;
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_WITH_CACHE());
break;
}
- case _DELETE_ATTR: {
+ case _DELETE_ATTR_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
+ 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);
PyStackRef_CLOSE(owner);
stack_pointer = _PyFrame_GetStackPointer(frame);
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_WITH_CACHE());
break;
}
- case _STORE_GLOBAL: {
+ case _STORE_GLOBAL_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef v;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- v = stack_pointer[-1];
+ 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);
PyStackRef_CLOSE(v);
stack_pointer = _PyFrame_GetStackPointer(frame);
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_WITH_CACHE());
break;
}
- case _DELETE_GLOBAL: {
+ case _DELETE_GLOBAL_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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) {
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, 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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_LOCALS: {
+ case _LOAD_LOCALS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef locals;
PyObject *l = LOCALS();
if (l == NULL) {
_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);
- stack_pointer[0] = locals;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = locals;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _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: {
+ case _LOAD_NAME_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef v;
oparg = CURRENT_OPARG();
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
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();
}
v = PyStackRef_FromPyObjectSteal(v_o);
- stack_pointer[0] = v;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = v;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_GLOBAL: {
+ case _LOAD_GLOBAL_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *res;
oparg = CURRENT_OPARG();
res = &stack_pointer[0];
_PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(*res)) {
+ 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 += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _PUSH_NULL_CONDITIONAL: {
+ case _PUSH_NULL_CONDITIONAL_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_GLOBALS_VERSION_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ uint16_t version = (uint16_t)CURRENT_OPERAND0();
+ 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(DK_IS_UNICODE(keys));
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_GLOBALS_VERSION_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ uint16_t version = (uint16_t)CURRENT_OPERAND0();
+ PyDictObject *dict = (PyDictObject *)GLOBALS();
+ if (!PyDict_CheckExact(dict)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ assert(DK_IS_UNICODE(keys));
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_GLOBALS_VERSION_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ uint16_t version = (uint16_t)CURRENT_OPERAND0();
+ PyDictObject *dict = (PyDictObject *)GLOBALS();
+ if (!PyDict_CheckExact(dict)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ assert(DK_IS_UNICODE(keys));
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_GLOBALS_VERSION: {
+ case _GUARD_GLOBALS_VERSION_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
PyDictObject *dict = (PyDictObject *)GLOBALS();
if (!PyDict_CheckExact(dict)) {
UOP_STAT_INC(uopcode, miss);
+ 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);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
assert(DK_IS_UNICODE(keys));
+ _tos_cache2 = _stack_item_2;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_GLOBAL_MODULE: {
+ case _LOAD_GLOBAL_MODULE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef res;
uint16_t version = (uint16_t)CURRENT_OPERAND0();
uint16_t index = (uint16_t)CURRENT_OPERAND1();
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(DK_IS_UNICODE(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);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_GLOBAL_BUILTINS: {
+ case _LOAD_GLOBAL_BUILTINS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef res;
uint16_t version = (uint16_t)CURRENT_OPERAND0();
uint16_t index = (uint16_t)CURRENT_OPERAND1();
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(DK_IS_UNICODE(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);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _DELETE_FAST: {
+ case _DELETE_FAST_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
oparg = CURRENT_OPARG();
_PyStackRef v = GETLOCAL(oparg);
if (PyStackRef_IsNull(v)) {
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);
_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_WITH_CACHE());
break;
}
- case _MAKE_CELL: {
+ case _MAKE_CELL_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
_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_WITH_CACHE());
break;
}
- case _DELETE_DEREF: {
+ case _DELETE_DEREF_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
oparg = CURRENT_OPARG();
PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, 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);
+ _tos_cache0 = PyStackRef_ZERO_BITS;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_FROM_DICT_OR_DEREF: {
+ case _LOAD_FROM_DICT_OR_DEREF_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef class_dict_st;
_PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- class_dict_st = stack_pointer[-1];
+ class_dict_st = _stack_item_0;
PyObject *value_o;
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);
+ stack_pointer[0] = class_dict_st;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(class_dict, name, &value_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (!value_o) {
_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_CLOSE(class_dict_st);
stack_pointer = _PyFrame_GetStackPointer(frame);
value = PyStackRef_FromPyObjectSteal(value_o);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_DEREF: {
+ case _LOAD_DEREF_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
oparg = CURRENT_OPARG();
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
_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[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_DEREF: {
+ case _STORE_DEREF_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef v;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- v = stack_pointer[-1];
+ 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);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_FREE_VARS_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_FREE_VARS_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_FREE_VARS_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _COPY_FREE_VARS: {
+ case _COPY_FREE_VARS_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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));
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_WITH_CACHE());
break;
}
- case _BUILD_STRING: {
+ case _BUILD_STRING_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *pieces;
_PyStackRef str;
oparg = CURRENT_OPARG();
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);
- stack_pointer[-oparg] = str;
- stack_pointer += 1 - oparg;
+ _tos_cache0 = str;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BUILD_INTERPOLATION: {
+ case _BUILD_INTERPOLATION_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *format;
_PyStackRef str;
_PyStackRef value;
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);
- stack_pointer[0] = interpolation;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = interpolation;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BUILD_TEMPLATE: {
+ case _BUILD_TEMPLATE_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef interpolations;
_PyStackRef strings;
_PyStackRef template;
- interpolations = stack_pointer[-1];
- strings = stack_pointer[-2];
+ _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);
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);
- stack_pointer[0] = template;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = template;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BUILD_TUPLE: {
+ case _BUILD_TUPLE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
- stack_pointer[-oparg] = tup;
- stack_pointer += 1 - oparg;
+ _tos_cache0 = tup;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BUILD_LIST: {
+ case _BUILD_LIST_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *values;
_PyStackRef list;
oparg = CURRENT_OPARG();
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);
- stack_pointer[-oparg] = list;
- stack_pointer += 1 - oparg;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LIST_EXTEND: {
+ case _LIST_EXTEND_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef iterable_st;
_PyStackRef list_st;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- iterable_st = stack_pointer[-1];
- list_st = stack_pointer[-2 - (oparg-1)];
+ 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);
_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));
_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _SET_UPDATE: {
+ case _SET_UPDATE_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef iterable;
_PyStackRef set;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- iterable = stack_pointer[-1];
- set = stack_pointer[-2 - (oparg-1)];
+ 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));
PyStackRef_CLOSE(iterable);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
+ 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_WITH_CACHE());
break;
}
- case _BUILD_SET: {
+ case _BUILD_SET_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *values;
_PyStackRef set;
oparg = CURRENT_OPARG();
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;
_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);
- stack_pointer[-oparg] = set;
- stack_pointer += 1 - oparg;
+ _tos_cache0 = set;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BUILD_MAP: {
+ case _BUILD_MAP_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *values;
_PyStackRef map;
oparg = CURRENT_OPARG();
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);
- stack_pointer[-oparg*2] = map;
- stack_pointer += 1 - oparg*2;
+ _tos_cache0 = map;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -oparg*2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _SETUP_ANNOTATIONS: {
+ case _SETUP_ANNOTATIONS_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
PyObject *ann_dict;
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();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (ann_dict == NULL) {
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);
Py_DECREF(ann_dict);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
}
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_WITH_CACHE());
break;
}
- case _DICT_UPDATE: {
+ case _DICT_UPDATE_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef update;
_PyStackRef dict;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- update = stack_pointer[-1];
- dict = stack_pointer[-2 - (oparg - 1)];
+ 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);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(update);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += -1;
_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _DICT_MERGE: {
+ case _DICT_MERGE_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef update;
_PyStackRef dict;
_PyStackRef callable;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- update = stack_pointer[-1];
- dict = stack_pointer[-2 - (oparg - 1)];
- callable = stack_pointer[-5 - (oparg - 1)];
+ 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);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(update);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += -1;
_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _MAP_ADD: {
+ case _MAP_ADD_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_pointer[-1];
- key = stack_pointer[-2];
- dict_st = stack_pointer[-3 - (oparg - 1)];
+ 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,
if (err != 0) {
stack_pointer += -2;
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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_SUPER_ATTR_ATTR: {
+ case _LOAD_SUPER_ATTR_ATTR_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_pointer[-1];
- class_st = stack_pointer[-2];
- global_super_st = stack_pointer[-3];
+ 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);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
if (!PyType_Check(class)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
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;
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);
- stack_pointer[0] = attr_st;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = attr_st;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_SUPER_ATTR_METHOD: {
+ case _LOAD_SUPER_ATTR_METHOD_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_pointer[-1];
- class_st = stack_pointer[-2];
- global_super_st = stack_pointer[-3];
+ 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);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
if (!PyType_Check(class)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
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;
+ 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_o = _PySuper_Lookup(cls, self, name,
Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (attr_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (method_found) {
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
attr = PyStackRef_FromPyObjectSteal(attr_o);
- stack_pointer[0] = attr;
- stack_pointer[1] = self_or_null;
- stack_pointer += 2;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = self_or_null;
+ _tos_cache0 = attr;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_ATTR: {
+ case _LOAD_ATTR_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
- _PyStackRef *attr;
+ _PyStackRef attr;
_PyStackRef *self_or_null;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
- attr = &stack_pointer[-1];
- self_or_null = &stack_pointer[0];
+ owner = _stack_item_0;
+ self_or_null = &stack_pointer[1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 1);
if (oparg & 1) {
- *attr = PyStackRef_NULL;
+ _PyCStackRef method;
+ stack_pointer[0] = owner;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
- int is_meth = _PyObject_GetMethodStackRef(tstate, PyStackRef_AsPyObjectBorrow(owner), name, attr);
+ _PyThreadState_PushCStackRef(tstate, &method);
+ int is_meth = _PyObject_GetMethodStackRef(tstate, PyStackRef_AsPyObjectBorrow(owner), name, &method.ref);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (is_meth) {
- assert(!PyStackRef_IsNull(*attr));
+ assert(!PyStackRef_IsNull(method.ref));
self_or_null[0] = owner;
+ attr = _PyThreadState_PopCStackRefSteal(tstate, &method);
}
else {
stack_pointer += -1;
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (PyStackRef_IsNull(*attr)) {
+ self_or_null[0] = PyStackRef_NULL;
+ attr = _PyThreadState_PopCStackRefSteal(tstate, &method);
+ if (PyStackRef_IsNull(attr)) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- self_or_null[0] = PyStackRef_NULL;
stack_pointer += 1;
}
}
else {
+ stack_pointer[0] = owner;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (attr_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- *attr = PyStackRef_FromPyObjectSteal(attr_o);
- stack_pointer += 1;
+ attr = PyStackRef_FromPyObjectSteal(attr_o);
+ stack_pointer += 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);
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TYPE_VERSION_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ owner = stack_pointer[-1];
+ uint32_t type_version = (uint32_t)CURRENT_OPERAND0();
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TYPE_VERSION_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
+ uint32_t type_version = (uint32_t)CURRENT_OPERAND0();
+ 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(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TYPE_VERSION_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ 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(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache1 = owner;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TYPE_VERSION_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ 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(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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TYPE_VERSION_AND_LOCK_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ owner = stack_pointer[-1];
+ uint32_t type_version = (uint32_t)CURRENT_OPERAND0();
+ 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();
+ }
}
- stack_pointer += (oparg&1);
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_TYPE_VERSION: {
+ case _GUARD_TYPE_VERSION_AND_LOCK_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
- owner = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
uint32_t type_version = (uint32_t)CURRENT_OPERAND0();
- PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
+ PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
assert(type_version != 0);
+ if (!LOCK_OBJECT(owner_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TYPE_VERSION_AND_LOCK_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
+ assert(type_version != 0);
+ if (!LOCK_OBJECT(owner_o)) {
UOP_STAT_INC(uopcode, miss);
+ 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);
+ 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_WITH_CACHE());
break;
}
- case _GUARD_TYPE_VERSION_AND_LOCK: {
+ case _GUARD_TYPE_VERSION_AND_LOCK_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
- owner = stack_pointer[-1];
+ _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();
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
assert(type_version != 0);
if (!LOCK_OBJECT(owner_o)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
PyTypeObject *tp = Py_TYPE(owner_o);
UNLOCK_OBJECT(owner_o);
if (true) {
UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _CHECK_MANAGED_OBJECT_HAS_VALUES: {
+ case _CHECK_MANAGED_OBJECT_HAS_VALUES_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
owner = stack_pointer[-1];
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
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_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_MANAGED_OBJECT_HAS_VALUES_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_MANAGED_OBJECT_HAS_VALUES_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_MANAGED_OBJECT_HAS_VALUES_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_INSTANCE_VALUE: {
+ case _LOAD_ATTR_INSTANCE_VALUE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
- owner = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
uint16_t offset = (uint16_t)CURRENT_OPERAND0();
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(1);
JUMP_TO_JUMP_TARGET();
}
#ifdef Py_GIL_DISABLED
if (!increfed) {
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
}
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
- stack_pointer[-1] = attr;
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_MODULE: {
+ case _LOAD_ATTR_MODULE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
- owner = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
uint32_t dict_version = (uint32_t)CURRENT_OPERAND0();
uint16_t index = (uint16_t)CURRENT_OPERAND1();
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
if (Py_TYPE(owner_o)->tp_getattro != PyModule_Type.tp_getattro) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner_o)->md_dict;
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);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
assert(keys->dk_kind == DICT_KEYS_UNICODE);
PyObject *attr_o = FT_ATOMIC_LOAD_PTR_RELAXED(ep->me_value);
if (attr_o == NULL) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
#ifdef Py_GIL_DISABLED
if (!increfed) {
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
}
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
- stack_pointer[-1] = attr;
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_WITH_HINT: {
+ case _LOAD_ATTR_WITH_HINT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
+ owner = _stack_item_0;
uint16_t hint = (uint16_t)CURRENT_OPERAND0();
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);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
PyDictKeysObject *dk = FT_ATOMIC_LOAD_PTR(dict->ma_keys);
#ifdef Py_GIL_DISABLED
if (!_Py_IsOwnedByCurrentThread((PyObject *)dict) && !_PyObject_GC_IS_SHARED(dict)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
#endif
if (hint >= (size_t)FT_ATOMIC_LOAD_SSIZE_RELAXED(dk->dk_nentries)) {
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
}
if (dk->dk_kind != DICT_KEYS_UNICODE) {
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
}
if (FT_ATOMIC_LOAD_PTR_RELAXED(ep->me_key) != name) {
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
}
if (attr_o == NULL) {
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
}
if (!increfed) {
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
}
#else
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
- stack_pointer[-1] = attr;
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_SLOT: {
+ case _LOAD_ATTR_SLOT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
- owner = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
uint16_t index = (uint16_t)CURRENT_OPERAND0();
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(1);
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(1);
JUMP_TO_JUMP_TARGET();
}
#else
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
+ 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_WITH_CACHE());
break;
}
- case _CHECK_ATTR_CLASS: {
+ case _CHECK_ATTR_CLASS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
owner = stack_pointer[-1];
uint32_t type_version = (uint32_t)CURRENT_OPERAND0();
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_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_ATTR_CLASS_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
+ uint32_t type_version = (uint32_t)CURRENT_OPERAND0();
+ PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
+ if (!PyType_Check(owner_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_ATTR_CLASS_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
+ if (!PyType_Check(owner_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_ATTR_CLASS_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
+ if (!PyType_Check(owner_o)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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);
+ 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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_CLASS: {
+ case _LOAD_ATTR_CLASS_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
- owner = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
PyObject *descr = (PyObject *)CURRENT_OPERAND0();
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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_PROPERTY_FRAME: {
+ case _LOAD_ATTR_PROPERTY_FRAME_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef new_frame;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
+ owner = _stack_item_0;
PyObject *fget = (PyObject *)CURRENT_OPERAND0();
assert((oparg & 1) == 0);
assert(Py_IS_TYPE(fget, &PyFunction_Type));
PyCodeObject *code = (PyCodeObject *)f->func_code;
if ((code->co_flags & (CO_VARKEYWORDS | CO_VARARGS | CO_OPTIMIZED)) != CO_OPTIMIZED) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
if (code->co_kwonlyargcount) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
if (code->co_argcount != 1) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) {
UOP_STAT_INC(uopcode, miss);
+ 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);
- stack_pointer[-1] = new_frame;
+ _tos_cache0 = new_frame;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _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: {
+ case _GUARD_DORV_NO_DICT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
owner = stack_pointer[-1];
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_DORV_NO_DICT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_DORV_NO_DICT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_DORV_NO_DICT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- case _STORE_ATTR_INSTANCE_VALUE: {
+ case _STORE_ATTR_INSTANCE_VALUE_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef value;
- owner = stack_pointer[-1];
- value = stack_pointer[-2];
+ _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();
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
STAT_INC(STORE_ATTR, hit);
_PyDictValues_AddToInsertionOrder(values, index);
}
UNLOCK_OBJECT(owner_o);
- stack_pointer += -2;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
Py_XDECREF(old_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_ATTR_WITH_HINT: {
+ case _STORE_ATTR_WITH_HINT_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
- value = stack_pointer[-2];
+ owner = _stack_item_1;
+ value = _stack_item_0;
uint16_t hint = (uint16_t)CURRENT_OPERAND0();
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);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
if (!LOCK_OBJECT(dict)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
assert(PyDict_CheckExact((PyObject *)dict));
UNLOCK_OBJECT(dict);
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
}
UNLOCK_OBJECT(dict);
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
}
UNLOCK_OBJECT(dict);
if (true) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
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(tstate->interp, PyDict_EVENT_MODIFIED, dict, name, PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
Py_XDECREF(old_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _STORE_ATTR_SLOT: {
+ case _STORE_ATTR_SLOT_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef value;
- owner = stack_pointer[-1];
- value = stack_pointer[-2];
+ _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();
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
if (!LOCK_OBJECT(owner_o)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
char *addr = (char *)owner_o + index;
PyObject *old_value = *(PyObject **)addr;
FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value));
UNLOCK_OBJECT(owner_o);
- stack_pointer += -2;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
Py_XDECREF(old_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COMPARE_OP: {
+ case _COMPARE_OP_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ 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;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (oparg & 16) {
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);
}
- stack_pointer[0] = res;
- stack_pointer += 1;
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _COMPARE_OP_FLOAT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ 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);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyFloat_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyFloat_ExactDealloc);
+ res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _COMPARE_OP_FLOAT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef right;
+ _PyStackRef left;
+ _PyStackRef res;
+ _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);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyFloat_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyFloat_ExactDealloc);
+ res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _COMPARE_OP_FLOAT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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);
+ PyStackRef_CLOSE_SPECIALIZED(left, _PyFloat_ExactDealloc);
+ PyStackRef_CLOSE_SPECIALIZED(right, _PyFloat_ExactDealloc);
+ res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False;
+ _tos_cache0 = res;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COMPARE_OP_FLOAT: {
+ case _COMPARE_OP_FLOAT_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
oparg = CURRENT_OPARG();
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ 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);
PyStackRef_CLOSE_SPECIALIZED(left, _PyFloat_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(right, _PyFloat_ExactDealloc);
res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = res;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = res;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COMPARE_OP_INT: {
+ case _COMPARE_OP_INT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ 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));
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = res;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COMPARE_OP_STR: {
+ case _COMPARE_OP_STR_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ 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);
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;
- stack_pointer[-2] = res;
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _IS_OP: {
+ case _IS_OP_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef b;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ right = _stack_item_1;
+ left = _stack_item_0;
int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg;
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyStackRef tmp = right;
right = PyStackRef_NULL;
- stack_pointer[-1] = right;
+ stack_pointer[0] = left;
+ stack_pointer[1] = right;
PyStackRef_CLOSE(tmp);
tmp = left;
left = PyStackRef_NULL;
- stack_pointer[-2] = left;
+ stack_pointer[0] = left;
PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- stack_pointer += -2;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
b = res ? PyStackRef_True : PyStackRef_False;
- stack_pointer[0] = b;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = b;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CONTAINS_OP: {
+ case _CONTAINS_OP_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef b;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ 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);
_PyStackRef tmp = right;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res < 0) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[0] = b;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = b;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_TOS_ANY_SET: {
+ case _GUARD_TOS_ANY_SET_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_ANY_SET_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = tos;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_ANY_SET_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_TOS_ANY_SET_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- case _CONTAINS_OP_SET: {
+ case _CONTAINS_OP_SET_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef b;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ 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);
_PyStackRef tmp = right;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res < 0) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[0] = b;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = b;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CONTAINS_OP_DICT: {
+ case _CONTAINS_OP_DICT_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef b;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ right = _stack_item_1;
+ left = _stack_item_0;
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyDict_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);
_PyStackRef tmp = right;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res < 0) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[0] = b;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = b;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_EG_MATCH: {
+ case _CHECK_EG_MATCH_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef match_type_st;
_PyStackRef exc_value_st;
_PyStackRef rest;
_PyStackRef match;
- match_type_st = stack_pointer[-1];
- exc_value_st = stack_pointer[-2];
+ _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);
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;
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)) {
}
rest = PyStackRef_FromPyObjectSteal(rest_o);
match = PyStackRef_FromPyObjectSteal(match_o);
- stack_pointer[0] = rest;
- stack_pointer[1] = match;
- stack_pointer += 2;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = match;
+ _tos_cache0 = rest;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_EXC_MATCH: {
+ case _CHECK_EXC_MATCH_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef right;
_PyStackRef left;
_PyStackRef b;
- right = stack_pointer[-1];
- left = stack_pointer[-2];
+ _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);
PyStackRef_CLOSE(right);
stack_pointer = _PyFrame_GetStackPointer(frame);
b = res ? PyStackRef_True : PyStackRef_False;
- stack_pointer[0] = b;
- stack_pointer += 1;
+ _tos_cache1 = b;
+ _tos_cache0 = left;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _IMPORT_NAME: {
+ case _IMPORT_NAME_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef fromlist;
_PyStackRef level;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- fromlist = stack_pointer[-1];
- level = stack_pointer[-2];
+ fromlist = _stack_item_1;
+ level = _stack_item_0;
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ stack_pointer[0] = level;
+ stack_pointer[1] = fromlist;
+ stack_pointer += 2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_ImportName(tstate, frame, name,
PyStackRef_AsPyObjectBorrow(fromlist),
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);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _IMPORT_FROM: {
+ case _IMPORT_FROM_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef from;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- from = stack_pointer[-1];
+ from = _stack_item_0;
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ stack_pointer[0] = from;
+ stack_pointer += 1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _POP_JUMP_IF_TRUE is not a viable micro-op for tier 2 because it is replaced */
- case _IS_NONE: {
+ case _IS_NONE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
_PyStackRef b;
- value = stack_pointer[-1];
+ _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;
}
- stack_pointer[-1] = b;
+ _tos_cache0 = b;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _JUMP_BACKWARD_NO_INTERRUPT is not a viable micro-op for tier 2 because it is replaced */
- case _GET_LEN: {
+ case _GET_LEN_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef obj;
_PyStackRef len;
- obj = stack_pointer[-1];
+ _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);
- stack_pointer[0] = len;
- stack_pointer += 1;
+ _tos_cache1 = len;
+ _tos_cache0 = obj;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _MATCH_CLASS: {
+ case _MATCH_CLASS_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_pointer[-1];
- type = stack_pointer[-2];
- subject = stack_pointer[-3];
+ 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),
}
else {
if (_PyErr_Occurred(tstate)) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
attrs = PyStackRef_None;
}
- stack_pointer[0] = attrs;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = attrs;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _MATCH_MAPPING: {
+ case _MATCH_MAPPING_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
- stack_pointer[0] = res;
- stack_pointer += 1;
+ _tos_cache1 = res;
+ _tos_cache0 = subject;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _MATCH_MAPPING_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _MATCH_MAPPING_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _MATCH_SEQUENCE: {
+ case _MATCH_SEQUENCE_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
- stack_pointer[0] = res;
- stack_pointer += 1;
+ _tos_cache1 = res;
+ _tos_cache0 = subject;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _MATCH_SEQUENCE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _MATCH_SEQUENCE_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _MATCH_KEYS: {
+ case _MATCH_KEYS_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef keys;
_PyStackRef subject;
_PyStackRef values_or_none;
- keys = stack_pointer[-1];
- subject = stack_pointer[-2];
+ _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);
- stack_pointer[0] = values_or_none;
- stack_pointer += 1;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GET_ITER: {
+ case _GET_ITER_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef iterable;
_PyStackRef iter;
_PyStackRef index_or_null;
- iterable = stack_pointer[-1];
+ _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);
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);
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;
- stack_pointer += 1;
}
- stack_pointer[-1] = iter;
- stack_pointer[0] = index_or_null;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache1 = index_or_null;
+ _tos_cache0 = iter;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GET_YIELD_FROM_ITER: {
+ case _GET_YIELD_FROM_ITER_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef iterable;
_PyStackRef iter;
- iterable = stack_pointer[-1];
+ _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;
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);
stack_pointer[-1] = iterable;
PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
}
- stack_pointer[-1] = iter;
+ _tos_cache0 = iter;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _FOR_ITER is not a viable micro-op for tier 2 because it is replaced */
- case _FOR_ITER_TIER_TWO: {
+ case _FOR_ITER_TIER_TWO_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null_or_index;
_PyStackRef iter;
_PyStackRef next;
- null_or_index = stack_pointer[-1];
- iter = stack_pointer[-2];
+ _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);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
}
next = item;
- stack_pointer[-1] = null_or_index;
- stack_pointer[0] = next;
- stack_pointer += 1;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 because it is instrumented */
- case _ITER_CHECK_LIST: {
+ case _ITER_CHECK_LIST_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null_or_index;
_PyStackRef iter;
null_or_index = stack_pointer[-1];
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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_LIST_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_LIST_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_LIST_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 because it is replaced */
+
+ case _GUARD_NOT_EXHAUSTED_LIST_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOT_EXHAUSTED_LIST_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 because it is replaced */
+ case _GUARD_NOT_EXHAUSTED_LIST_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
- case _GUARD_NOT_EXHAUSTED_LIST: {
+ case _GUARD_NOT_EXHAUSTED_LIST_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null_or_index;
_PyStackRef iter;
- null_or_index = stack_pointer[-1];
- iter = stack_pointer[-2];
+ _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);
+ 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_WITH_CACHE());
break;
}
/* _ITER_NEXT_LIST is not a viable micro-op for tier 2 because it is replaced */
- case _ITER_NEXT_LIST_TIER_TWO: {
+ case _ITER_NEXT_LIST_TIER_TWO_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null_or_index;
_PyStackRef iter;
_PyStackRef next;
- null_or_index = stack_pointer[-1];
- iter = stack_pointer[-2];
+ _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);
+ SET_CURRENT_CACHED_VALUES(0);
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);
- stack_pointer[-1] = null_or_index;
- stack_pointer[0] = next;
- stack_pointer += 1;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _ITER_CHECK_TUPLE: {
+ case _ITER_CHECK_TUPLE_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null_or_index;
_PyStackRef iter;
null_or_index = stack_pointer[-1];
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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_TUPLE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_TUPLE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_TUPLE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 because it is replaced */
- case _GUARD_NOT_EXHAUSTED_TUPLE: {
+ case _GUARD_NOT_EXHAUSTED_TUPLE_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null_or_index;
_PyStackRef iter;
null_or_index = stack_pointer[-1];
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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOT_EXHAUSTED_TUPLE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOT_EXHAUSTED_TUPLE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache1 = null_or_index;
+ _tos_cache0 = iter;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOT_EXHAUSTED_TUPLE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
break;
}
- case _ITER_NEXT_TUPLE: {
+ case _ITER_NEXT_TUPLE_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null_or_index;
_PyStackRef iter;
_PyStackRef next;
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);
- stack_pointer[-1] = null_or_index;
- stack_pointer[0] = next;
- stack_pointer += 1;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_NEXT_TUPLE_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_NEXT_TUPLE_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _ITER_CHECK_RANGE: {
+ case _ITER_CHECK_RANGE_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ }
+ #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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_RANGE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ #ifdef Py_GIL_DISABLED
+ if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_RANGE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ #ifdef Py_GIL_DISABLED
+ if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_CHECK_RANGE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef iter;
+ _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);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
#ifdef Py_GIL_DISABLED
if (!_PyObject_IsUniquelyReferenced((PyObject *)r)) {
UOP_STAT_INC(uopcode, miss);
+ 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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 because it is replaced */
- case _GUARD_NOT_EXHAUSTED_RANGE: {
+ case _GUARD_NOT_EXHAUSTED_RANGE_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_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_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOT_EXHAUSTED_RANGE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef iter;
+ _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) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOT_EXHAUSTED_RANGE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(Py_TYPE(r) == &PyRangeIter_Type);
+ if (r->len <= 0) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = iter;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOT_EXHAUSTED_RANGE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef iter;
+ _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) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
+ _tos_cache2 = _stack_item_2;
+ _tos_cache1 = iter;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _ITER_NEXT_RANGE: {
+ case _ITER_NEXT_RANGE_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef iter;
_PyStackRef next;
iter = stack_pointer[-2];
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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_NEXT_RANGE_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _ITER_NEXT_RANGE_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef iter;
+ _PyStackRef next;
+ _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();
}
next = PyStackRef_FromPyObjectSteal(res);
- stack_pointer[0] = next;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache2 = next;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = iter;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _FOR_ITER_GEN_FRAME: {
+ case _FOR_ITER_GEN_FRAME_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef iter;
_PyStackRef gen_frame;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- iter = stack_pointer[-2];
+ iter = _stack_item_0;
PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter);
if (Py_TYPE(gen) != &PyGen_Type) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
#ifdef Py_GIL_DISABLED
if (!_PyObject_IsUniquelyReferenced((PyObject *)gen)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
#endif
if (gen->gi_frame_state >= FRAME_EXECUTING) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(FOR_ITER, hit);
pushed_frame->previous = frame;
frame->return_offset = (uint16_t)( 2u + oparg);
gen_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[0] = gen_frame;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache2 = gen_frame;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = iter;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _INSERT_NULL: {
+ case _INSERT_NULL_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef self;
_PyStackRef *method_and_self;
- self = stack_pointer[-1];
- method_and_self = &stack_pointer[-1];
+ _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;
- stack_pointer += 1;
+ SET_CURRENT_CACHED_VALUES(0);
+ stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_SPECIAL: {
+ case _LOAD_SPECIAL_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *method_and_self;
oparg = CURRENT_OPARG();
method_and_self = &stack_pointer[-2];
_PyErr_Format(tstate, PyExc_TypeError, errfmt, owner);
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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _WITH_EXCEPT_START: {
+ case _WITH_EXCEPT_START_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef val;
_PyStackRef lasti;
_PyStackRef exit_self;
_PyStackRef exit_func;
_PyStackRef res;
- val = stack_pointer[-1];
- lasti = stack_pointer[-3];
- exit_self = stack_pointer[-4];
- exit_func = stack_pointer[-5];
+ _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);
(void)lasti;
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);
PyObject *res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,
(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
Py_XDECREF(original_tb);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
+ _tos_cache2 = res;
+ _tos_cache1 = val;
+ _tos_cache0 = _stack_item_1;
+ SET_CURRENT_CACHED_VALUES(3);
+ stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _PUSH_EXC_INFO: {
+ case _PUSH_EXC_INFO_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef exc;
_PyStackRef prev_exc;
_PyStackRef new_exc;
assert(PyStackRef_ExceptionInstanceCheck(exc));
exc_info->exc_value = PyStackRef_AsPyObjectNew(exc);
new_exc = exc;
- stack_pointer[-1] = prev_exc;
- stack_pointer[0] = new_exc;
- stack_pointer += 1;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _PUSH_EXC_INFO_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef exc;
+ _PyStackRef prev_exc;
+ _PyStackRef new_exc;
+ _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);
+ }
+ else {
+ prev_exc = PyStackRef_None;
+ }
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _PUSH_EXC_INFO_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef exc;
+ _PyStackRef prev_exc;
+ _PyStackRef new_exc;
+ _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;
+ }
+ 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_WITH_CACHE());
break;
}
- case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: {
+ case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
owner = stack_pointer[-1];
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
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);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_flags & Py_TPFLAGS_INLINE_VALUES);
+ PyDictValues *ivs = _PyObject_InlineValues(owner_o);
+ if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_flags & Py_TPFLAGS_INLINE_VALUES);
+ PyDictValues *ivs = _PyObject_InlineValues(owner_o);
+ if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_flags & Py_TPFLAGS_INLINE_VALUES);
+ PyDictValues *ivs = _PyObject_InlineValues(owner_o);
+ if (!FT_ATOMIC_LOAD_UINT8(ivs->valid)) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _GUARD_KEYS_VERSION: {
+ case _GUARD_KEYS_VERSION_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
owner = stack_pointer[-1];
uint32_t keys_version = (uint32_t)CURRENT_OPERAND0();
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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_KEYS_VERSION_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
+ uint32_t keys_version = (uint32_t)CURRENT_OPERAND0();
+ 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(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_KEYS_VERSION_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ owner = _stack_item_1;
+ uint32_t keys_version = (uint32_t)CURRENT_OPERAND0();
+ 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(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache1 = owner;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_KEYS_VERSION_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ 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(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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_METHOD_WITH_VALUES: {
+ case _LOAD_ATTR_METHOD_WITH_VALUES_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
_PyStackRef self;
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
self = owner;
- stack_pointer[-1] = attr;
- stack_pointer[0] = self;
- stack_pointer += 1;
+ _tos_cache1 = self;
+ _tos_cache0 = attr;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_ATTR_METHOD_WITH_VALUES_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef attr;
+ _PyStackRef self;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = CURRENT_OPARG();
+ owner = _stack_item_0;
+ PyObject *descr = (PyObject *)CURRENT_OPERAND0();
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_ATTR_METHOD_WITH_VALUES_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef attr;
+ _PyStackRef self;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = CURRENT_OPARG();
+ owner = _stack_item_1;
+ PyObject *descr = (PyObject *)CURRENT_OPERAND0();
+ 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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_METHOD_NO_DICT: {
+ case _LOAD_ATTR_METHOD_NO_DICT_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
_PyStackRef self;
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
self = owner;
- stack_pointer[-1] = attr;
- stack_pointer[0] = self;
- stack_pointer += 1;
+ _tos_cache1 = self;
+ _tos_cache0 = attr;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: {
+ case _LOAD_ATTR_METHOD_NO_DICT_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
+ _PyStackRef self;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
+ owner = _stack_item_0;
+ PyObject *descr = (PyObject *)CURRENT_OPERAND0();
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_ATTR_METHOD_NO_DICT_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef attr;
+ _PyStackRef self;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ oparg = CURRENT_OPARG();
+ owner = _stack_item_1;
+ PyObject *descr = (PyObject *)CURRENT_OPERAND0();
+ 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(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef attr;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = CURRENT_OPARG();
+ owner = _stack_item_0;
PyObject *descr = (PyObject *)CURRENT_OPERAND0();
assert((oparg & 1) == 0);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
stack_pointer = _PyFrame_GetStackPointer(frame);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[0] = attr;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = attr;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: {
+ case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
+ owner = _stack_item_0;
PyObject *descr = (PyObject *)CURRENT_OPERAND0();
assert((oparg & 1) == 0);
assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
stack_pointer = _PyFrame_GetStackPointer(frame);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[0] = attr;
- stack_pointer += 1;
+ _tos_cache0 = attr;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_ATTR_METHOD_LAZY_DICT_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ owner = stack_pointer[-1];
+ uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0();
+ 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 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_ATTR_METHOD_LAZY_DICT_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ owner = _stack_item_0;
+ uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0();
+ 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(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = owner;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_ATTR_METHOD_LAZY_DICT_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ owner = _stack_item_1;
+ uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0();
+ 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(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache1 = owner;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_ATTR_METHOD_LAZY_DICT_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0();
+ 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(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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_ATTR_METHOD_LAZY_DICT_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef owner;
+ _PyStackRef attr;
+ _PyStackRef self;
+ oparg = CURRENT_OPARG();
+ owner = stack_pointer[-1];
+ PyObject *descr = (PyObject *)CURRENT_OPERAND0();
+ 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_WITH_CACHE());
break;
}
- case _CHECK_ATTR_METHOD_LAZY_DICT: {
+ case _LOAD_ATTR_METHOD_LAZY_DICT_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
- owner = stack_pointer[-1];
- uint16_t dictoffset = (uint16_t)CURRENT_OPERAND0();
- 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);
- JUMP_TO_JUMP_TARGET();
- }
+ _PyStackRef attr;
+ _PyStackRef self;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ oparg = CURRENT_OPARG();
+ owner = _stack_item_0;
+ PyObject *descr = (PyObject *)CURRENT_OPERAND0();
+ 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_WITH_CACHE());
break;
}
- case _LOAD_ATTR_METHOD_LAZY_DICT: {
+ case _LOAD_ATTR_METHOD_LAZY_DICT_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef owner;
_PyStackRef attr;
_PyStackRef self;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- owner = stack_pointer[-1];
+ owner = _stack_item_1;
PyObject *descr = (PyObject *)CURRENT_OPERAND0();
assert(oparg & 1);
STAT_INC(LOAD_ATTR, hit);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
self = owner;
- stack_pointer[-1] = attr;
- stack_pointer[0] = self;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache2 = self;
+ _tos_cache1 = attr;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _MAYBE_EXPAND_METHOD: {
+ case _MAYBE_EXPAND_METHOD_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef self_or_null;
_PyStackRef callable;
oparg = CURRENT_OPARG();
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);
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _MONITOR_CALL is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
- case _PY_FRAME_GENERAL: {
+ case _PY_FRAME_GENERAL_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
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);
- stack_pointer[0] = new_frame;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = new_frame;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_FUNCTION_VERSION: {
+ case _CHECK_FUNCTION_VERSION_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_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();
+ }
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_FUNCTION_VERSION_INLINE_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ uint32_t func_version = (uint32_t)CURRENT_OPERAND0();
+ PyObject *callable_o = (PyObject *)CURRENT_OPERAND1();
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_FUNCTION_VERSION_INLINE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ uint32_t func_version = (uint32_t)CURRENT_OPERAND0();
+ PyObject *callable_o = (PyObject *)CURRENT_OPERAND1();
+ 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(1);
JUMP_TO_JUMP_TARGET();
}
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_FUNCTION_VERSION_INLINE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ uint32_t func_version = (uint32_t)CURRENT_OPERAND0();
+ PyObject *callable_o = (PyObject *)CURRENT_OPERAND1();
+ 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(2);
JUMP_TO_JUMP_TARGET();
}
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_FUNCTION_VERSION_INLINE: {
+ case _CHECK_FUNCTION_VERSION_INLINE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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();
PyObject *callable_o = (PyObject *)CURRENT_OPERAND1();
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(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_WITH_CACHE());
break;
}
- case _CHECK_METHOD_VERSION: {
+ case _CHECK_METHOD_VERSION_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null;
_PyStackRef callable;
oparg = CURRENT_OPARG();
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();
}
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();
}
if (((PyFunctionObject *)func)->func_version != func_version) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
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_WITH_CACHE());
break;
}
- case _EXPAND_METHOD: {
+ case _EXPAND_METHOD_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef self_or_null;
_PyStackRef callable;
oparg = CURRENT_OPARG();
_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_IS_NOT_PY_CALLABLE: {
+ case _CHECK_IS_NOT_PY_CALLABLE_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_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();
}
if (Py_TYPE(callable_o) == &PyMethod_Type) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_NON_PY_GENERAL: {
+ case _CALL_NON_PY_GENERAL_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
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);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: {
+ case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null;
_PyStackRef callable;
oparg = CURRENT_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) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: {
+ case _INIT_CALL_BOUND_METHOD_EXACT_ARGS_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef self_or_null;
_PyStackRef callable;
oparg = CURRENT_OPARG();
_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_PEP_523_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ if (tstate->interp->eval_frame) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_PEP_523_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ if (tstate->interp->eval_frame) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_PEP_523_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ if (tstate->interp->eval_frame) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _CHECK_PEP_523: {
+ case _CHECK_PEP_523_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
if (tstate->interp->eval_frame) {
UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _CHECK_FUNCTION_EXACT_ARGS: {
+ case _CHECK_FUNCTION_EXACT_ARGS_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef self_or_null;
_PyStackRef callable;
oparg = CURRENT_OPARG();
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();
}
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_STACK_SPACE: {
+ case _CHECK_STACK_SPACE_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef callable;
oparg = CURRENT_OPARG();
callable = stack_pointer[-2 - oparg];
PyCodeObject *code = (PyCodeObject *)func->func_code;
if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_RECURSION_REMAINING_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ if (tstate->py_recursion_remaining <= 1) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_RECURSION_REMAINING_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ if (tstate->py_recursion_remaining <= 1) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_RECURSION_REMAINING_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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(2);
JUMP_TO_JUMP_TARGET();
}
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_RECURSION_REMAINING: {
+ case _CHECK_RECURSION_REMAINING_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
if (tstate->py_recursion_remaining <= 1) {
UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _INIT_CALL_PY_EXACT_ARGS_0: {
+ case _INIT_CALL_PY_EXACT_ARGS_0_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
first_non_self_local[i] = args[i];
}
new_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[-2 - oparg] = new_frame;
- stack_pointer += -1 - oparg;
+ _tos_cache0 = new_frame;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _INIT_CALL_PY_EXACT_ARGS_1: {
+ case _INIT_CALL_PY_EXACT_ARGS_1_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
first_non_self_local[i] = args[i];
}
new_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[-2 - oparg] = new_frame;
- stack_pointer += -1 - oparg;
+ _tos_cache0 = new_frame;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _INIT_CALL_PY_EXACT_ARGS_2: {
+ case _INIT_CALL_PY_EXACT_ARGS_2_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
first_non_self_local[i] = args[i];
}
new_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[-2 - oparg] = new_frame;
- stack_pointer += -1 - oparg;
+ _tos_cache0 = new_frame;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2 - oparg;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _INIT_CALL_PY_EXACT_ARGS_3_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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];
+ }
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _INIT_CALL_PY_EXACT_ARGS_4_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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];
+ }
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _INIT_CALL_PY_EXACT_ARGS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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];
+ }
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _PUSH_FRAME_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef new_frame;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ new_frame = _stack_item_0;
+ assert(tstate->interp->eval_frame == NULL);
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_NULL_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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 = null;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_NULL_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef null;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ null = stack_pointer[-1];
+ if (!PyStackRef_IsNull(null)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_NULL_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef null;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ null = _stack_item_0;
+ if (!PyStackRef_IsNull(null)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = null;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_NULL_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_NOT_NULL_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ }
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_NOT_NULL_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef nos;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ nos = stack_pointer[-1];
+ PyObject *o = PyStackRef_AsPyObjectBorrow(nos);
+ if (o == NULL) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_NOS_NOT_NULL_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _INIT_CALL_PY_EXACT_ARGS_3: {
- _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];
+ case _GUARD_NOS_NOT_NULL_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ SET_CURRENT_CACHED_VALUES(3);
+ JUMP_TO_JUMP_TARGET();
}
- new_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[-2 - oparg] = new_frame;
- stack_pointer += -1 - oparg;
- 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_WITH_CACHE());
break;
}
- case _INIT_CALL_PY_EXACT_ARGS_4: {
- _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];
+ case _GUARD_THIRD_NULL_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
}
- new_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[-2 - oparg] = new_frame;
- stack_pointer += -1 - oparg;
+ _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_WITH_CACHE());
break;
}
- case _INIT_CALL_PY_EXACT_ARGS: {
- _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];
+ case _GUARD_THIRD_NULL_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef null;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ null = stack_pointer[-2];
+ if (!PyStackRef_IsNull(null)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
}
- new_frame = PyStackRef_Wrap(pushed_frame);
- stack_pointer[-2 - oparg] = new_frame;
- stack_pointer += -1 - oparg;
+ _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_WITH_CACHE());
break;
}
- case _PUSH_FRAME: {
- _PyStackRef new_frame;
- new_frame = stack_pointer[-1];
- assert(tstate->interp->eval_frame == NULL);
- _PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
+ case _GUARD_THIRD_NULL_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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);
+ SET_CURRENT_CACHED_VALUES(2);
+ 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__);
- _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();
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_NOS_NULL: {
+ case _GUARD_THIRD_NULL_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null;
- null = stack_pointer[-2];
+ _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)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
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_WITH_CACHE());
break;
}
- case _GUARD_NOS_NOT_NULL: {
- _PyStackRef nos;
- nos = stack_pointer[-2];
- PyObject *o = PyStackRef_AsPyObjectBorrow(nos);
- if (o == NULL) {
+ case _GUARD_CALLABLE_TYPE_1_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ }
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_TYPE_1_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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) {
UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _GUARD_THIRD_NULL: {
- _PyStackRef null;
- null = stack_pointer[-3];
- if (!PyStackRef_IsNull(null)) {
+ case _GUARD_CALLABLE_TYPE_1_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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(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_WITH_CACHE());
break;
}
- case _GUARD_CALLABLE_TYPE_1: {
+ case _GUARD_CALLABLE_TYPE_1_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef callable;
- callable = stack_pointer[-3];
+ _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 *)&PyType_Type) {
UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _CALL_TYPE_1: {
+ case _CALL_TYPE_1_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef arg;
_PyStackRef null;
_PyStackRef callable;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
oparg = CURRENT_OPARG();
- arg = stack_pointer[-1];
- null = stack_pointer[-2];
- callable = stack_pointer[-3];
+ arg = _stack_item_2;
+ null = _stack_item_1;
+ callable = _stack_item_0;
PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg);
assert(oparg == 1);
(void)callable;
(void)null;
STAT_INC(CALL, hit);
res = PyStackRef_FromPyObjectNew(Py_TYPE(arg_o));
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _tos_cache0 = res;
+ _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_WITH_CACHE());
break;
}
- case _GUARD_CALLABLE_STR_1: {
+ case _GUARD_CALLABLE_STR_1_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_STR_1_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef callable;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ callable = stack_pointer[-2];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ if (callable_o != (PyObject *)&PyUnicode_Type) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_STR_1_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_STR_1_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ if (callable_o != (PyObject *)&PyUnicode_Type) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _CALL_STR_1: {
+ case _CALL_STR_1_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef arg;
_PyStackRef null;
_PyStackRef callable;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
oparg = CURRENT_OPARG();
- arg = stack_pointer[-1];
- null = stack_pointer[-2];
- callable = stack_pointer[-3];
+ arg = _stack_item_2;
+ null = _stack_item_1;
+ callable = _stack_item_0;
PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg);
assert(oparg == 1);
STAT_INC(CALL, hit);
+ stack_pointer[0] = callable;
+ stack_pointer[1] = null;
+ stack_pointer[2] = arg;
+ stack_pointer += 3;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Str(arg_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(arg);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_CALLABLE_TUPLE_1: {
+ case _GUARD_CALLABLE_TUPLE_1_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_TUPLE_1_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_TUPLE_1_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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(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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_TUPLE_1_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ if (callable_o != (PyObject *)&PyTuple_Type) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _CALL_TUPLE_1: {
+ case _CALL_TUPLE_1_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef arg;
_PyStackRef null;
_PyStackRef callable;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
oparg = CURRENT_OPARG();
- arg = stack_pointer[-1];
- null = stack_pointer[-2];
- callable = stack_pointer[-3];
+ arg = _stack_item_2;
+ null = _stack_item_1;
+ callable = _stack_item_0;
PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg);
assert(oparg == 1);
STAT_INC(CALL, hit);
+ stack_pointer[0] = callable;
+ stack_pointer[1] = null;
+ 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);
PyStackRef_CLOSE(arg);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_AND_ALLOCATE_OBJECT: {
+ case _CHECK_AND_ALLOCATE_OBJECT_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef self_or_null;
_PyStackRef callable;
oparg = CURRENT_OPARG();
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);
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);
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);
_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CREATE_INIT_FRAME: {
+ case _CREATE_INIT_FRAME_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self;
_PyStackRef init;
_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);
- stack_pointer[0] = init_frame;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = init_frame;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _EXIT_INIT_CHECK: {
+ case _EXIT_INIT_CHECK_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef should_be_none;
- should_be_none = stack_pointer[-1];
+ _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();
}
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = PyStackRef_ZERO_BITS;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_BUILTIN_CLASS: {
+ case _CALL_BUILTIN_CLASS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
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;
}
if (tp->tp_vectorcall == NULL) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
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);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_BUILTIN_O: {
+ case _CALL_BUILTIN_O_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
}
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);
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);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_BUILTIN_FAST: {
+ case _CALL_BUILTIN_FAST_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
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);
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);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_BUILTIN_FAST_WITH_KEYWORDS: {
+ case _CALL_BUILTIN_FAST_WITH_KEYWORDS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
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 | METH_KEYWORDS)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
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);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_CALLABLE_LEN: {
+ case _GUARD_CALLABLE_LEN_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ SET_CURRENT_CACHED_VALUES(3);
+ stack_pointer += -3;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_LEN_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef callable;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_LEN_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef callable;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_LEN_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ 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(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_WITH_CACHE());
break;
}
- case _CALL_LEN: {
+ case _CALL_LEN_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef arg;
_PyStackRef null;
_PyStackRef callable;
_PyStackRef res;
- arg = stack_pointer[-1];
- null = stack_pointer[-2];
- callable = stack_pointer[-3];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
+ arg = _stack_item_2;
+ null = _stack_item_1;
+ callable = _stack_item_0;
(void)null;
STAT_INC(CALL, hit);
PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg);
+ stack_pointer[0] = callable;
+ stack_pointer[1] = null;
+ 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();
}
stack_pointer += -1;
PyStackRef_CLOSE(callable);
stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_CALLABLE_ISINSTANCE: {
+ case _GUARD_CALLABLE_ISINSTANCE_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ }
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_ISINSTANCE_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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(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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_ISINSTANCE_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef callable;
+ _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);
+ 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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_ISINSTANCE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef callable;
+ _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);
+ 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_WITH_CACHE());
break;
}
- case _CALL_ISINSTANCE: {
+ case _CALL_ISINSTANCE_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef cls;
_PyStackRef instance;
_PyStackRef null;
_PyStackRef callable;
_PyStackRef res;
- cls = stack_pointer[-1];
- instance = stack_pointer[-2];
- null = stack_pointer[-3];
- callable = stack_pointer[-4];
+ _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;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
int retval = PyObject_IsInstance(inst_o, cls_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (retval < 0) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
(void)null;
stack_pointer = _PyFrame_GetStackPointer(frame);
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_CALLABLE_LIST_APPEND: {
+ case _GUARD_CALLABLE_LIST_APPEND_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_LIST_APPEND_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef callable;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_LIST_APPEND_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef callable;
+ _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);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_CALLABLE_LIST_APPEND_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ 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(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_WITH_CACHE());
break;
}
- case _CALL_LIST_APPEND: {
+ case _CALL_LIST_APPEND_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef arg;
_PyStackRef self;
_PyStackRef callable;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
oparg = CURRENT_OPARG();
- arg = stack_pointer[-1];
- self = stack_pointer[-2];
- callable = stack_pointer[-3];
+ 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);
+ 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);
- stack_pointer += -2;
+ stack_pointer[0] = callable;
+ stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(self);
PyStackRef_CLOSE(callable);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
#if TIER_ONE
assert(next_instr->op.code == POP_TOP);
SKIP_OVER(1);
#endif
+ _tos_cache0 = PyStackRef_ZERO_BITS;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_METHOD_DESCRIPTOR_O: {
+ case _CALL_METHOD_DESCRIPTOR_O_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
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];
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);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: {
+ case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
}
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;
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);
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);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_METHOD_DESCRIPTOR_NOARGS: {
+ case _CALL_METHOD_DESCRIPTOR_NOARGS_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
}
if (total_args != 1) {
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;
PyObject *self = PyStackRef_AsPyObjectBorrow(self_stackref);
if (!Py_IS_TYPE(self, method->d_common.d_type)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
if (meth->ml_flags != METH_NOARGS) {
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);
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);
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_METHOD_DESCRIPTOR_FAST: {
+ case _CALL_METHOD_DESCRIPTOR_FAST_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
}
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) {
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();
}
STAT_INC(CALL, hit);
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);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _MONITOR_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
- case _MAYBE_EXPAND_METHOD_KW: {
+ case _MAYBE_EXPAND_METHOD_KW_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef self_or_null;
_PyStackRef callable;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- self_or_null = stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - 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;
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectNew(method);
- stack_pointer[-3 - oparg] = callable;
- stack_pointer[-2 - oparg] = self_or_null;
+ 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;
}
- stack_pointer[-3 - oparg] = callable;
- stack_pointer[-2 - oparg] = self_or_null;
+ _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;
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _DO_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
- case _PY_FRAME_KW: {
+ case _PY_FRAME_KW_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef kwnames;
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
_PyStackRef new_frame;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- kwnames = stack_pointer[-1];
- args = &stack_pointer[-1 - oparg];
- self_or_null = stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - 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;
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,
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);
- stack_pointer[0] = new_frame;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = new_frame;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_FUNCTION_VERSION_KW: {
+ case _CHECK_FUNCTION_VERSION_KW_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef callable;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- callable = stack_pointer[-3 - oparg];
+ callable = stack_pointer[-2 - oparg];
uint32_t func_version = (uint32_t)CURRENT_OPERAND0();
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
if (!PyFunction_Check(callable_o)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
PyFunctionObject *func = (PyFunctionObject *)callable_o;
if (func->func_version != func_version) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CHECK_METHOD_VERSION_KW: {
+ case _CHECK_METHOD_VERSION_KW_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null;
_PyStackRef callable;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- null = stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - oparg];
+ null = stack_pointer[-1 - oparg];
+ callable = stack_pointer[-2 - oparg];
uint32_t func_version = (uint32_t)CURRENT_OPERAND0();
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
if (Py_TYPE(callable_o) != &PyMethod_Type) {
UOP_STAT_INC(uopcode, miss);
+ 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);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
if (((PyFunctionObject *)func)->func_version != func_version) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
if (!PyStackRef_IsNull(null)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _EXPAND_METHOD_KW: {
+ case _EXPAND_METHOD_KW_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef self_or_null;
_PyStackRef callable;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- self_or_null = stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - 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);
self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
assert(PyStackRef_FunctionCheck(callable));
- stack_pointer[-3 - oparg] = callable;
- stack_pointer[-2 - oparg] = self_or_null;
+ 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_WITH_CACHE());
break;
}
- case _CHECK_IS_NOT_PY_CALLABLE_KW: {
+ case _CHECK_IS_NOT_PY_CALLABLE_KW_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef callable;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- callable = stack_pointer[-3 - 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(1);
JUMP_TO_JUMP_TARGET();
}
if (Py_TYPE(callable_o) == &PyMethod_Type) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
JUMP_TO_JUMP_TARGET();
}
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CALL_KW_NON_PY: {
+ case _CALL_KW_NON_PY_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef kwnames;
_PyStackRef *args;
_PyStackRef self_or_null;
_PyStackRef callable;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- kwnames = stack_pointer[-1];
- args = &stack_pointer[-1 - oparg];
- self_or_null = stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - 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);
#endif
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,
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);
- stack_pointer[-3 - oparg] = res;
- stack_pointer += -2 - oparg;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _MAKE_CALLARGS_A_TUPLE: {
+ case _MAKE_CALLARGS_A_TUPLE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef callargs;
_PyStackRef func;
- callargs = stack_pointer[-2];
- func = stack_pointer[-4];
+ _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;
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
}
- stack_pointer[-2] = callargs;
+ _tos_cache2 = _stack_item_2;
+ _tos_cache1 = callargs;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
- case _MAKE_FUNCTION: {
+ case _MAKE_FUNCTION_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef codeobj_st;
_PyStackRef func;
- codeobj_st = stack_pointer[-1];
+ _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());
PyStackRef_CLOSE(codeobj_st);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (func_obj == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
_PyFunction_SetVersion(
func_obj, ((PyCodeObject *)codeobj)->co_version);
func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);
- stack_pointer[0] = func;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = func;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _SET_FUNCTION_ATTRIBUTE: {
+ case _SET_FUNCTION_ATTRIBUTE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef func_in;
_PyStackRef attr_st;
_PyStackRef func_out;
PyObject **ptr = (PyObject **)(((char *)func) + offset);
assert(*ptr == NULL);
*ptr = attr;
- stack_pointer[-2] = func_out;
+ _tos_cache0 = func_out;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SET_FUNCTION_ATTRIBUTE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _SET_FUNCTION_ATTRIBUTE_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _SET_FUNCTION_ATTRIBUTE_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
break;
}
- case _RETURN_GENERATOR: {
+ case _RETURN_GENERATOR_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef res;
assert(PyStackRef_FunctionCheck(frame->f_funcobj));
PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (gen == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
assert(STACK_LEVEL() == 0);
stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_FromPyObjectStealMortal((PyObject *)gen);
LLTRACE_RESUME_FRAME();
- stack_pointer[0] = res;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BUILD_SLICE: {
+ case _BUILD_SLICE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef *args;
_PyStackRef slice;
oparg = CURRENT_OPARG();
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);
- stack_pointer[0] = slice;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = slice;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _CONVERT_VALUE: {
+ case _CONVERT_VALUE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
_PyStackRef result;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- value = stack_pointer[-1];
+ 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);
PyStackRef_CLOSE(value);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (result_o == NULL) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
result = PyStackRef_FromPyObjectSteal(result_o);
- stack_pointer[0] = result;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = result;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _FORMAT_SIMPLE: {
+ case _FORMAT_SIMPLE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
_PyStackRef res;
- value = stack_pointer[-1];
+ _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);
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;
- stack_pointer += -1;
}
- stack_pointer[0] = res;
- stack_pointer += 1;
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _FORMAT_WITH_SPEC_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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 = 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();
+ }
+ res = PyStackRef_FromPyObjectSteal(res_o);
+ _tos_cache0 = res;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_1_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_1_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_1_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_2_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _FORMAT_WITH_SPEC: {
- _PyStackRef fmt_spec;
- _PyStackRef value;
- _PyStackRef res;
- fmt_spec = stack_pointer[-1];
- value = stack_pointer[-2];
- _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) {
- JUMP_TO_ERROR();
- }
- res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[0] = res;
- stack_pointer += 1;
+ case _COPY_2_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef bottom;
+ _PyStackRef top;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COPY_1: {
+ case _COPY_2_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef bottom;
_PyStackRef top;
- bottom = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ bottom = _stack_item_0;
top = PyStackRef_DUP(bottom);
- stack_pointer[0] = top;
- stack_pointer += 1;
+ _tos_cache2 = top;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = bottom;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_3_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COPY_2: {
+ case _COPY_3_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef bottom;
_PyStackRef top;
+ _PyStackRef _stack_item_0 = _tos_cache0;
bottom = stack_pointer[-2];
top = PyStackRef_DUP(bottom);
- stack_pointer[0] = top;
- stack_pointer += 1;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COPY_3: {
+ case _COPY_3_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef bottom;
_PyStackRef top;
- bottom = stack_pointer[-3];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ bottom = stack_pointer[-1];
+ top = PyStackRef_DUP(bottom);
+ _tos_cache2 = top;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _COPY_3_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_0;
top = PyStackRef_DUP(bottom);
- stack_pointer[0] = top;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COPY: {
+ case _COPY_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef bottom;
_PyStackRef top;
oparg = CURRENT_OPARG();
bottom = stack_pointer[-1 - (oparg-1)];
top = PyStackRef_DUP(bottom);
- stack_pointer[0] = top;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = top;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _BINARY_OP: {
+ case _BINARY_OP_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef rhs;
_PyStackRef lhs;
_PyStackRef res;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
oparg = CURRENT_OPARG();
- rhs = stack_pointer[-1];
- lhs = stack_pointer[-2];
+ 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) {
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = res;
+ _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_WITH_CACHE());
break;
}
- case _SWAP_2: {
+ case _SWAP_2_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef top;
_PyStackRef bottom;
top = stack_pointer[-1];
_PyStackRef temp = bottom;
bottom = top;
top = temp;
- stack_pointer[-2] = bottom;
- stack_pointer[-1] = top;
+ _tos_cache1 = top;
+ _tos_cache0 = bottom;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -2;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SWAP_2_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef top;
+ _PyStackRef bottom;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SWAP_2_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef top;
+ _PyStackRef bottom;
+ _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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SWAP_2_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef top;
+ _PyStackRef bottom;
+ _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;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _SWAP_3: {
+ case _SWAP_3_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef top;
_PyStackRef bottom;
top = stack_pointer[-1];
_PyStackRef temp = bottom;
bottom = top;
top = temp;
- stack_pointer[-3] = bottom;
- stack_pointer[-1] = top;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _SWAP_3_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef top;
+ _PyStackRef bottom;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SWAP_3_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef top;
+ _PyStackRef bottom;
+ _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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SWAP_3_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef top;
+ _PyStackRef bottom;
+ _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;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = bottom;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _SWAP: {
+ case _SWAP_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef top;
_PyStackRef bottom;
+ _PyStackRef _stack_item_0 = _tos_cache0;
oparg = CURRENT_OPARG();
- top = stack_pointer[-1];
- bottom = stack_pointer[-2 - (oparg-2)];
+ top = _stack_item_0;
+ bottom = stack_pointer[-1 - (oparg-2)];
_PyStackRef temp = bottom;
bottom = top;
top = temp;
- stack_pointer[-2 - (oparg-2)] = bottom;
- stack_pointer[-1] = top;
+ _tos_cache0 = top;
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer[-1 - (oparg-2)] = bottom;
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
/* _INSTRUMENTED_POP_JUMP_IF_NOT_NONE is not a viable micro-op for tier 2 because it is instrumented */
- case _GUARD_IS_TRUE_POP: {
+ case _GUARD_IS_TRUE_POP_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_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();
+ }
+ SET_CURRENT_CACHED_VALUES(0);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_TRUE_POP_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_TRUE_POP_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_TRUE_POP_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ _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_WITH_CACHE());
break;
}
- case _GUARD_IS_FALSE_POP: {
+ case _GUARD_IS_FALSE_POP_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_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();
+ }
+ SET_CURRENT_CACHED_VALUES(0);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_FALSE_POP_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_FALSE_POP_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_FALSE_POP_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ _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_WITH_CACHE());
break;
}
- case _GUARD_IS_NONE_POP: {
+ case _GUARD_IS_NONE_POP_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef val;
val = stack_pointer[-1];
int is_none = PyStackRef_IsNone(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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_IS_NOT_NONE_POP: {
+ case _GUARD_IS_NONE_POP_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef val;
- val = stack_pointer[-1];
+ _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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_NONE_POP_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef val;
+ _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();
+ }
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_NONE_POP_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef val;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
+ val = _stack_item_2;
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IS_NOT_NONE_POP_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef val;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ val = _stack_item_0;
int is_none = PyStackRef_IsNone(val);
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_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);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = PyStackRef_ZERO_BITS;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _JUMP_TO_TOP_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ JUMP_TO_JUMP_TARGET();
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SET_IP_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0();
+ frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr;
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SET_IP_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0();
+ frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SET_IP_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0();
+ frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SET_IP_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
+ PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0();
+ 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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_STACK_SPACE_OPERAND_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ uint32_t framesize = (uint32_t)CURRENT_OPERAND0();
+ assert(framesize <= INT_MAX);
+ if (!_PyThreadState_HasStackSpace(tstate, framesize)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ if (tstate->py_recursion_remaining <= 1) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_JUMP_TARGET();
}
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _JUMP_TO_TOP: {
- JUMP_TO_JUMP_TARGET();
+ case _CHECK_STACK_SPACE_OPERAND_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ uint32_t framesize = (uint32_t)CURRENT_OPERAND0();
+ assert(framesize <= INT_MAX);
+ if (!_PyThreadState_HasStackSpace(tstate, framesize)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ if (tstate->py_recursion_remaining <= 1) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _SET_IP: {
- PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND0();
- frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr;
+ case _CHECK_STACK_SPACE_OPERAND_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ uint32_t framesize = (uint32_t)CURRENT_OPERAND0();
+ assert(framesize <= INT_MAX);
+ if (!_PyThreadState_HasStackSpace(tstate, framesize)) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ if (tstate->py_recursion_remaining <= 1) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _CHECK_STACK_SPACE_OPERAND: {
+ case _CHECK_STACK_SPACE_OPERAND_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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();
assert(framesize <= INT_MAX);
if (!_PyThreadState_HasStackSpace(tstate, framesize)) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
if (tstate->py_recursion_remaining <= 1) {
UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _SAVE_RETURN_OFFSET_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SAVE_RETURN_OFFSET_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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;
+ #endif
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SAVE_RETURN_OFFSET_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _SAVE_RETURN_OFFSET: {
+ case _SAVE_RETURN_OFFSET_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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);
#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(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _EXIT_TRACE: {
+ case _EXIT_TRACE_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
PyObject *exit_p = (PyObject *)CURRENT_OPERAND0();
_PyExitData *exit = (_PyExitData *)exit_p;
#if defined(Py_DEBUG) && !defined(_Py_JIT)
}
#endif
tstate->jit_exit = exit;
+ SET_CURRENT_CACHED_VALUES(0);
TIER2_TO_TIER2(exit->executor);
- break;
}
- case _DYNAMIC_EXIT: {
+ case _EXIT_TRACE_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ PyObject *exit_p = (PyObject *)CURRENT_OPERAND0();
+ _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;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ TIER2_TO_TIER2(exit->executor);
+ }
+
+ case _EXIT_TRACE_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ PyObject *exit_p = (PyObject *)CURRENT_OPERAND0();
+ _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);
+ 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: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
+ PyObject *exit_p = (PyObject *)CURRENT_OPERAND0();
+ _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);
+ }
+
+ case _DYNAMIC_EXIT_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ PyObject *exit_p = (PyObject *)CURRENT_OPERAND0();
+ #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);
+ GOTO_TIER_ONE(frame->instr_ptr);
+ }
+
+ case _DYNAMIC_EXIT_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ PyObject *exit_p = (PyObject *)CURRENT_OPERAND0();
+ #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;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ GOTO_TIER_ONE(frame->instr_ptr);
+ }
+
+ case _DYNAMIC_EXIT_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
PyObject *exit_p = (PyObject *)CURRENT_OPERAND0();
#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]);
(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);
+ }
+ case _DYNAMIC_EXIT_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
+ PyObject *exit_p = (PyObject *)CURRENT_OPERAND0();
+ #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);
+ }
+
+ case _CHECK_VALIDITY_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_VALIDITY_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ if (!current_executor->vm_data.valid) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _CHECK_VALIDITY_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ if (!current_executor->vm_data.valid) {
+ UOP_STAT_INC(uopcode, miss);
+ 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_WITH_CACHE());
break;
}
- case _CHECK_VALIDITY: {
+ case _CHECK_VALIDITY_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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(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_WITH_CACHE());
break;
}
- case _LOAD_CONST_INLINE: {
+ case _LOAD_CONST_INLINE_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
value = PyStackRef_FromPyObjectNew(ptr);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_CONST_INLINE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
+ value = PyStackRef_FromPyObjectNew(ptr);
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_CONST_INLINE_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _POP_TOP_LOAD_CONST_INLINE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef pop;
+ _PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ pop = _stack_item_0;
+ PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(pop);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ value = PyStackRef_FromPyObjectNew(ptr);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_CONST_INLINE_BORROW_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef value;
+ PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
+ value = PyStackRef_FromPyObjectBorrow(ptr);
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _POP_TOP_LOAD_CONST_INLINE: {
- _PyStackRef pop;
+ case _LOAD_CONST_INLINE_BORROW_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
- pop = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
- _PyFrame_SetStackPointer(frame, stack_pointer);
- PyStackRef_CLOSE(pop);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- value = PyStackRef_FromPyObjectNew(ptr);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ value = PyStackRef_FromPyObjectBorrow(ptr);
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_CONST_INLINE_BORROW: {
+ case _LOAD_CONST_INLINE_BORROW_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef value;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
value = PyStackRef_FromPyObjectBorrow(ptr);
- stack_pointer[0] = value;
- stack_pointer += 1;
- 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_WITH_CACHE());
break;
}
- case _POP_CALL: {
+ case _POP_CALL_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null;
_PyStackRef callable;
- null = stack_pointer[-1];
- callable = stack_pointer[-2];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ null = _stack_item_1;
+ callable = _stack_item_0;
(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_WITH_CACHE());
break;
}
- case _POP_CALL_ONE: {
+ case _POP_CALL_ONE_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef pop;
_PyStackRef null;
_PyStackRef callable;
- pop = stack_pointer[-1];
- null = stack_pointer[-2];
- callable = stack_pointer[-3];
- stack_pointer += -1;
+ _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);
_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_WITH_CACHE());
break;
}
- case _POP_CALL_TWO: {
+ case _POP_CALL_TWO_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef pop2;
_PyStackRef pop1;
_PyStackRef null;
_PyStackRef callable;
- pop2 = stack_pointer[-1];
- pop1 = stack_pointer[-2];
- null = stack_pointer[-3];
- callable = stack_pointer[-4];
- stack_pointer += -1;
+ _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);
_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_WITH_CACHE());
break;
}
- case _POP_TOP_LOAD_CONST_INLINE_BORROW: {
+ case _POP_TOP_LOAD_CONST_INLINE_BORROW_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef pop;
_PyStackRef value;
- pop = stack_pointer[-1];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ pop = _stack_item_0;
PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
- stack_pointer += -1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(pop);
stack_pointer = _PyFrame_GetStackPointer(frame);
value = PyStackRef_FromPyObjectBorrow(ptr);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _POP_TWO_LOAD_CONST_INLINE_BORROW: {
+ case _POP_TWO_LOAD_CONST_INLINE_BORROW_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef pop2;
_PyStackRef pop1;
_PyStackRef value;
- pop2 = stack_pointer[-1];
- pop1 = stack_pointer[-2];
+ _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();
- stack_pointer += -1;
+ stack_pointer[0] = pop1;
+ stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(pop2);
PyStackRef_CLOSE(pop1);
stack_pointer = _PyFrame_GetStackPointer(frame);
value = PyStackRef_FromPyObjectBorrow(ptr);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _POP_CALL_LOAD_CONST_INLINE_BORROW: {
+ case _POP_CALL_LOAD_CONST_INLINE_BORROW_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef null;
_PyStackRef callable;
_PyStackRef value;
- null = stack_pointer[-1];
- callable = stack_pointer[-2];
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ null = _stack_item_1;
+ callable = _stack_item_0;
PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
(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);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW: {
+ case _POP_CALL_ONE_LOAD_CONST_INLINE_BORROW_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef pop;
_PyStackRef null;
_PyStackRef callable;
_PyStackRef value;
- pop = stack_pointer[-1];
- null = stack_pointer[-2];
- callable = stack_pointer[-3];
+ _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;
PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
- stack_pointer += -1;
+ 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);
PyStackRef_CLOSE(callable);
stack_pointer = _PyFrame_GetStackPointer(frame);
value = PyStackRef_FromPyObjectBorrow(ptr);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW: {
+ case _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef pop2;
_PyStackRef pop1;
_PyStackRef null;
_PyStackRef callable;
_PyStackRef value;
- pop2 = stack_pointer[-1];
- pop1 = stack_pointer[-2];
- null = stack_pointer[-3];
- callable = stack_pointer[-4];
+ _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();
- 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);
PyStackRef_CLOSE(callable);
stack_pointer = _PyFrame_GetStackPointer(frame);
value = PyStackRef_FromPyObjectBorrow(ptr);
- stack_pointer[0] = value;
- stack_pointer += 1;
- ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ _tos_cache0 = value;
+ _tos_cache1 = PyStackRef_ZERO_BITS;
+ _tos_cache2 = PyStackRef_ZERO_BITS;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_CONST_UNDER_INLINE: {
+ case _LOAD_CONST_UNDER_INLINE_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyStackRef old;
_PyStackRef value;
_PyStackRef new;
PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
new = old;
value = PyStackRef_FromPyObjectNew(ptr);
- stack_pointer[-1] = value;
- stack_pointer[0] = new;
+ _tos_cache1 = new;
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(2);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_CONST_UNDER_INLINE_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef old;
+ _PyStackRef value;
+ _PyStackRef new;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ old = _stack_item_0;
+ PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
+ new = old;
+ value = PyStackRef_FromPyObjectNew(ptr);
+ _tos_cache1 = new;
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_CONST_UNDER_INLINE_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ 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_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_CONST_UNDER_INLINE_BORROW_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef old;
+ _PyStackRef value;
+ _PyStackRef new;
+ old = stack_pointer[-1];
+ PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
+ 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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_CONST_UNDER_INLINE_BORROW_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef old;
+ _PyStackRef value;
+ _PyStackRef new;
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ old = _stack_item_0;
+ PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
+ new = old;
+ value = PyStackRef_FromPyObjectBorrow(ptr);
+ _tos_cache1 = new;
+ _tos_cache0 = value;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _LOAD_CONST_UNDER_INLINE_BORROW_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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();
+ new = old;
+ value = PyStackRef_FromPyObjectBorrow(ptr);
+ _tos_cache2 = new;
+ _tos_cache1 = value;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _START_EXECUTOR_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ PyObject *executor = (PyObject *)CURRENT_OPERAND0();
+ #ifndef _Py_JIT
+ assert(current_executor == (_PyExecutorObject*)executor);
+ #endif
+ assert(tstate->jit_exit == NULL || tstate->jit_exit->executor == current_executor);
+ tstate->current_executor = (PyObject *)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_WITH_CACHE());
+ break;
+ }
+
+ case _MAKE_WARM_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ current_executor->vm_data.warm = true;
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _MAKE_WARM_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ current_executor->vm_data.warm = true;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _MAKE_WARM_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ current_executor->vm_data.warm = true;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _MAKE_WARM_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
+ current_executor->vm_data.warm = true;
+ _tos_cache2 = _stack_item_2;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _FATAL_ERROR_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ assert(0);
+ Py_FatalError("Fatal error uop executed.");
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _FATAL_ERROR_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _FATAL_ERROR_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _FATAL_ERROR_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _DEOPT_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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());
+ }
+
+ case _DEOPT_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ stack_pointer[0] = _stack_item_0;
+ stack_pointer += 1;
+ 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 _DEOPT_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ 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 _DEOPT_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ 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_WITH_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_WITH_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());
+ }
+
+ case _HANDLE_PENDING_AND_DEOPT_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ 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_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ oparg = CURRENT_OPARG();
+ uint32_t target = (uint32_t)CURRENT_OPERAND0();
+ assert(oparg == 0);
+ frame->instr_ptr = _PyFrame_GetBytecode(frame) + target;
+ SET_CURRENT_CACHED_VALUES(0);
+ GOTO_TIER_ONE(NULL);
+ }
+
+ case _SPILL_OR_RELOAD_r01: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _tos_cache0 = stack_pointer[-1];
+ SET_CURRENT_CACHED_VALUES(1);
+ stack_pointer += -1;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SPILL_OR_RELOAD_r02: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _SPILL_OR_RELOAD_r03: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_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_WITH_CACHE());
+ break;
+ }
+
+ case _SPILL_OR_RELOAD_r10: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ SET_CURRENT_CACHED_VALUES(0);
+ stack_pointer[0] = _stack_item_0;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _SPILL_OR_RELOAD_r12: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _SPILL_OR_RELOAD_r13: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _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_WITH_CACHE());
+ break;
+ }
+
+ case _SPILL_OR_RELOAD_r20: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _LOAD_CONST_UNDER_INLINE_BORROW: {
- _PyStackRef old;
- _PyStackRef value;
- _PyStackRef new;
- old = stack_pointer[-1];
- PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
- new = old;
- value = PyStackRef_FromPyObjectBorrow(ptr);
- stack_pointer[-1] = value;
- stack_pointer[0] = new;
+ case _SPILL_OR_RELOAD_r21: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _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_WITH_CACHE());
break;
}
- case _START_EXECUTOR: {
- PyObject *executor = (PyObject *)CURRENT_OPERAND0();
- #ifndef _Py_JIT
- assert(current_executor == (_PyExecutorObject*)executor);
- #endif
- assert(tstate->jit_exit == NULL || tstate->jit_exit->executor == current_executor);
- tstate->current_executor = (PyObject *)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);
- JUMP_TO_JUMP_TARGET();
- }
- }
+ case _SPILL_OR_RELOAD_r23: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_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;
+ ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _MAKE_WARM: {
- current_executor->vm_data.warm = true;
+ case _SPILL_OR_RELOAD_r30: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _FATAL_ERROR: {
- assert(0);
- Py_FatalError("Fatal error uop executed.");
+ case _SPILL_OR_RELOAD_r31: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_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__);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _DEOPT: {
- GOTO_TIER_ONE((frame->owner == FRAME_OWNED_BY_INTERPRETER)
- ? _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS_PTR : _PyFrame_GetBytecode(frame) + CURRENT_TARGET());
+ case _SPILL_OR_RELOAD_r32: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
+ _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_WITH_CACHE());
break;
}
- case _HANDLE_PENDING_AND_DEOPT: {
- _PyFrame_SetStackPointer(frame, stack_pointer);
- int err = _Py_HandlePending(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET());
+ case _TIER2_RESUME_CHECK_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ #if defined(__EMSCRIPTEN__)
+ if (_Py_emscripten_signal_clock == 0) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ 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);
+ if (eval_breaker & _PY_EVAL_EVENTS_MASK) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ assert(tstate->tracing || eval_breaker == FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version));
+ SET_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _ERROR_POP_N: {
- oparg = CURRENT_OPARG();
- uint32_t target = (uint32_t)CURRENT_OPERAND0();
- assert(oparg == 0);
- frame->instr_ptr = _PyFrame_GetBytecode(frame) + target;
- GOTO_TIER_ONE(NULL);
+ case _TIER2_RESUME_CHECK_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ #if defined(__EMSCRIPTEN__)
+ if (_Py_emscripten_signal_clock == 0) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ 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);
+ if (eval_breaker & _PY_EVAL_EVENTS_MASK) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ assert(tstate->tracing || eval_breaker == FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version));
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _TIER2_RESUME_CHECK_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ #if defined(__EMSCRIPTEN__)
+ if (_Py_emscripten_signal_clock == 0) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ 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);
+ if (eval_breaker & _PY_EVAL_EVENTS_MASK) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ assert(tstate->tracing || eval_breaker == FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version));
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _TIER2_RESUME_CHECK: {
+ case _TIER2_RESUME_CHECK_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
#if defined(__EMSCRIPTEN__)
if (_Py_emscripten_signal_clock == 0) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
_Py_emscripten_signal_clock -= Py_EMSCRIPTEN_SIGNAL_HANDLING;
uintptr_t eval_breaker = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker);
if (eval_breaker & _PY_EVAL_EVENTS_MASK) {
UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(3);
JUMP_TO_JUMP_TARGET();
}
assert(tstate->tracing || eval_breaker == FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version));
+ _tos_cache2 = _stack_item_2;
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _COLD_EXIT: {
+ case _COLD_EXIT_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_PyExitData *exit = tstate->jit_exit;
assert(exit != NULL);
assert(frame->owner < FRAME_OWNED_BY_INTERPRETER);
Py_INCREF(executor);
assert(tstate->jit_exit == exit);
exit->executor = executor;
+ SET_CURRENT_CACHED_VALUES(0);
TIER2_TO_TIER2(exit->executor);
}
else {
if (!backoff_counter_triggers(temperature)) {
exit->temperature = advance_backoff_counter(temperature);
+ SET_CURRENT_CACHED_VALUES(0);
GOTO_TIER_ONE(target);
}
_PyExecutorObject *previous_executor = _PyExecutor_FromExit(exit);
if (succ) {
GOTO_TIER_ONE_CONTINUE_TRACING(target);
}
+ SET_CURRENT_CACHED_VALUES(0);
GOTO_TIER_ONE(target);
}
- break;
}
- case _COLD_DYNAMIC_EXIT: {
+ case _COLD_DYNAMIC_EXIT_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
_Py_CODEUNIT *target = frame->instr_ptr;
+ SET_CURRENT_CACHED_VALUES(0);
GOTO_TIER_ONE(target);
+ }
+
+ case _GUARD_IP__PUSH_FRAME_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ #define OFFSET_OF__PUSH_FRAME ((0))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF__PUSH_FRAME;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF__PUSH_FRAME;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ #undef OFFSET_OF__PUSH_FRAME
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP__PUSH_FRAME_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ #define OFFSET_OF__PUSH_FRAME ((0))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF__PUSH_FRAME;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF__PUSH_FRAME;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ #undef OFFSET_OF__PUSH_FRAME
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP__PUSH_FRAME_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ #define OFFSET_OF__PUSH_FRAME ((0))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF__PUSH_FRAME;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF__PUSH_FRAME;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ #undef OFFSET_OF__PUSH_FRAME
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_IP__PUSH_FRAME: {
+ case _GUARD_IP__PUSH_FRAME_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
#define OFFSET_OF__PUSH_FRAME ((0))
PyObject *ip = (PyObject *)CURRENT_OPERAND0();
_Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF__PUSH_FRAME;
frame->instr_ptr += OFFSET_OF__PUSH_FRAME;
if (true) {
UOP_STAT_INC(uopcode, miss);
+ 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);
#undef OFFSET_OF__PUSH_FRAME
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_YIELD_VALUE_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ #define OFFSET_OF_YIELD_VALUE ((1+INLINE_CACHE_ENTRIES_SEND))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_YIELD_VALUE;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_YIELD_VALUE;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ #undef OFFSET_OF_YIELD_VALUE
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_YIELD_VALUE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ #define OFFSET_OF_YIELD_VALUE ((1+INLINE_CACHE_ENTRIES_SEND))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_YIELD_VALUE;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_YIELD_VALUE;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ #undef OFFSET_OF_YIELD_VALUE
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_YIELD_VALUE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ #define OFFSET_OF_YIELD_VALUE ((1+INLINE_CACHE_ENTRIES_SEND))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_YIELD_VALUE;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_YIELD_VALUE;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ #undef OFFSET_OF_YIELD_VALUE
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_IP_YIELD_VALUE: {
+ case _GUARD_IP_YIELD_VALUE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
#define OFFSET_OF_YIELD_VALUE ((1+INLINE_CACHE_ENTRIES_SEND))
PyObject *ip = (PyObject *)CURRENT_OPERAND0();
_Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_YIELD_VALUE;
frame->instr_ptr += OFFSET_OF_YIELD_VALUE;
if (true) {
UOP_STAT_INC(uopcode, miss);
+ 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);
#undef OFFSET_OF_YIELD_VALUE
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_RETURN_VALUE_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ #define OFFSET_OF_RETURN_VALUE ((frame->return_offset))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_RETURN_VALUE;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_RETURN_VALUE;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ #undef OFFSET_OF_RETURN_VALUE
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_RETURN_VALUE_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ #define OFFSET_OF_RETURN_VALUE ((frame->return_offset))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_RETURN_VALUE;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_RETURN_VALUE;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ #undef OFFSET_OF_RETURN_VALUE
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_RETURN_VALUE_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ #define OFFSET_OF_RETURN_VALUE ((frame->return_offset))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_RETURN_VALUE;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_RETURN_VALUE;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ #undef OFFSET_OF_RETURN_VALUE
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_IP_RETURN_VALUE: {
+ case _GUARD_IP_RETURN_VALUE_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
#define OFFSET_OF_RETURN_VALUE ((frame->return_offset))
PyObject *ip = (PyObject *)CURRENT_OPERAND0();
_Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_RETURN_VALUE;
frame->instr_ptr += OFFSET_OF_RETURN_VALUE;
if (true) {
UOP_STAT_INC(uopcode, miss);
+ 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);
#undef OFFSET_OF_RETURN_VALUE
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_RETURN_GENERATOR_r00: {
+ CHECK_CURRENT_CACHED_VALUES(0);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ #define OFFSET_OF_RETURN_GENERATOR ((frame->return_offset))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_RETURN_GENERATOR;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_RETURN_GENERATOR;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(0);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ SET_CURRENT_CACHED_VALUES(0);
+ #undef OFFSET_OF_RETURN_GENERATOR
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_RETURN_GENERATOR_r11: {
+ CHECK_CURRENT_CACHED_VALUES(1);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ #define OFFSET_OF_RETURN_GENERATOR ((frame->return_offset))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_RETURN_GENERATOR;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_RETURN_GENERATOR;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(1);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(1);
+ #undef OFFSET_OF_RETURN_GENERATOR
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ break;
+ }
+
+ case _GUARD_IP_RETURN_GENERATOR_r22: {
+ CHECK_CURRENT_CACHED_VALUES(2);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ #define OFFSET_OF_RETURN_GENERATOR ((frame->return_offset))
+ PyObject *ip = (PyObject *)CURRENT_OPERAND0();
+ _Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_RETURN_GENERATOR;
+ if (target != (_Py_CODEUNIT *)ip) {
+ frame->instr_ptr += OFFSET_OF_RETURN_GENERATOR;
+ if (true) {
+ UOP_STAT_INC(uopcode, miss);
+ SET_CURRENT_CACHED_VALUES(2);
+ JUMP_TO_JUMP_TARGET();
+ }
+ }
+ _tos_cache1 = _stack_item_1;
+ _tos_cache0 = _stack_item_0;
+ SET_CURRENT_CACHED_VALUES(2);
+ #undef OFFSET_OF_RETURN_GENERATOR
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
- case _GUARD_IP_RETURN_GENERATOR: {
+ case _GUARD_IP_RETURN_GENERATOR_r33: {
+ CHECK_CURRENT_CACHED_VALUES(3);
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
+ _PyStackRef _stack_item_0 = _tos_cache0;
+ _PyStackRef _stack_item_1 = _tos_cache1;
+ _PyStackRef _stack_item_2 = _tos_cache2;
#define OFFSET_OF_RETURN_GENERATOR ((frame->return_offset))
PyObject *ip = (PyObject *)CURRENT_OPERAND0();
_Py_CODEUNIT *target = frame->instr_ptr + OFFSET_OF_RETURN_GENERATOR;
frame->instr_ptr += OFFSET_OF_RETURN_GENERATOR;
if (true) {
UOP_STAT_INC(uopcode, miss);
+ 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);
#undef OFFSET_OF_RETURN_GENERATOR
+ assert(WITHIN_STACK_BOUNDS_WITH_CACHE());
break;
}
projects / thirdparty / Python / cpython.git / commitdiff
