* Spill the evaluation around escaping calls in the generated interpreter and JIT.
* The code generator tracks live, cached values so they can be saved to memory when needed.
* Spills the stack pointer around escaping calls, so that the exact stack is visible to the cycle GC.
} _Py_SpecialMethod;
PyAPI_DATA(const _Py_SpecialMethod) _Py_SpecialMethods[];
+PyAPI_DATA(const size_t) _Py_FunctionAttributeOffsets[];
PyAPI_FUNC(int) _PyEval_CheckExceptStarTypeValid(PyThreadState *tstate, PyObject* right);
PyAPI_FUNC(int) _PyEval_CheckExceptTypeValid(PyThreadState *tstate, PyObject* right);
PyAPI_FUNC(void) _PyEval_LoadGlobalStackRef(PyObject *globals, PyObject *builtins, PyObject *name, _PyStackRef *writeto);
PyAPI_FUNC(PyObject *) _PyEval_GetAwaitable(PyObject *iterable, int oparg);
PyAPI_FUNC(PyObject *) _PyEval_LoadName(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObject *name);
+PyAPI_FUNC(int)
+_Py_Check_ArgsIterable(PyThreadState *tstate, PyObject *func, PyObject *args);
/* Bits that can be set in PyThreadState.eval_breaker */
#define _PY_GIL_DROP_REQUEST_BIT (1U << 0)
return 5;
case YIELD_VALUE:
return 1;
- case _DO_CALL_FUNCTION_EX:
- return 3 + (oparg & 1);
default:
return -1;
}
return 6;
case YIELD_VALUE:
return 1;
- case _DO_CALL_FUNCTION_EX:
- return 1;
default:
return -1;
}
[BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG },
[BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
- [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
+ [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG },
[BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG },
[BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[BINARY_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
+ [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG },
[BINARY_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG },
[BINARY_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG },
[BINARY_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG },
[CONTAINS_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[CONTAINS_OP_DICT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[CONTAINS_OP_SET] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG },
+ [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[COPY] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_PURE_FLAG },
[COPY_FREE_VARS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 },
[INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG },
- [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG },
+ [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
+ [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG },
[INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG },
[INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
- [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
- [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
+ [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
+ [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
- [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG },
+ [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, 0 },
[IS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG },
[LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG },
- [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
+ [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG },
[LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
[LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
- [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
+ [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG },
- [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
+ [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG },
[RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG },
- [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
+ [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[RETURN_VALUE] = { true, INSTR_FMT_IX, 0 },
- [SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
+ [SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
[SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[SET_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG },
+ [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_EXIT_FLAG },
[TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
[TO_BOOL_BOOL] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
- [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
+ [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
[TO_BOOL_LIST] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
[TO_BOOL_NONE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
- [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
+ [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
[UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[UNARY_NOT] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
[UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
[UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
[WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG },
- [_DO_CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
+ [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[JUMP_IF_FALSE] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[JUMP_IF_TRUE] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[UNPACK_SEQUENCE_TWO_TUPLE] = "UNPACK_SEQUENCE_TWO_TUPLE",
[WITH_EXCEPT_START] = "WITH_EXCEPT_START",
[YIELD_VALUE] = "YIELD_VALUE",
- [_DO_CALL_FUNCTION_EX] = "_DO_CALL_FUNCTION_EX",
};
#endif
[UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE,
[WITH_EXCEPT_START] = WITH_EXCEPT_START,
[YIELD_VALUE] = YIELD_VALUE,
- [_DO_CALL_FUNCTION_EX] = _DO_CALL_FUNCTION_EX,
};
#endif // NEED_OPCODE_METADATA
#define EXTRA_CASES \
+ case 116: \
case 117: \
case 118: \
case 119: \
#define _DICT_MERGE DICT_MERGE
#define _DICT_UPDATE DICT_UPDATE
#define _DO_CALL 356
-#define _DO_CALL_KW 357
-#define _DYNAMIC_EXIT 358
+#define _DO_CALL_FUNCTION_EX 357
+#define _DO_CALL_KW 358
+#define _DYNAMIC_EXIT 359
#define _END_SEND END_SEND
-#define _ERROR_POP_N 359
+#define _ERROR_POP_N 360
#define _EXIT_INIT_CHECK EXIT_INIT_CHECK
-#define _EXPAND_METHOD 360
-#define _EXPAND_METHOD_KW 361
-#define _FATAL_ERROR 362
+#define _EXPAND_METHOD 361
+#define _EXPAND_METHOD_KW 362
+#define _FATAL_ERROR 363
#define _FORMAT_SIMPLE FORMAT_SIMPLE
#define _FORMAT_WITH_SPEC FORMAT_WITH_SPEC
-#define _FOR_ITER 363
-#define _FOR_ITER_GEN_FRAME 364
-#define _FOR_ITER_TIER_TWO 365
+#define _FOR_ITER 364
+#define _FOR_ITER_GEN_FRAME 365
+#define _FOR_ITER_TIER_TWO 366
#define _GET_AITER GET_AITER
#define _GET_ANEXT GET_ANEXT
#define _GET_AWAITABLE GET_AWAITABLE
#define _GET_ITER GET_ITER
#define _GET_LEN GET_LEN
#define _GET_YIELD_FROM_ITER GET_YIELD_FROM_ITER
-#define _GUARD_BOTH_FLOAT 366
-#define _GUARD_BOTH_INT 367
-#define _GUARD_BOTH_UNICODE 368
-#define _GUARD_BUILTINS_VERSION 369
-#define _GUARD_DORV_NO_DICT 370
-#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 371
-#define _GUARD_GLOBALS_VERSION 372
-#define _GUARD_IS_FALSE_POP 373
-#define _GUARD_IS_NONE_POP 374
-#define _GUARD_IS_NOT_NONE_POP 375
-#define _GUARD_IS_TRUE_POP 376
-#define _GUARD_KEYS_VERSION 377
-#define _GUARD_NOS_FLOAT 378
-#define _GUARD_NOS_INT 379
-#define _GUARD_NOT_EXHAUSTED_LIST 380
-#define _GUARD_NOT_EXHAUSTED_RANGE 381
-#define _GUARD_NOT_EXHAUSTED_TUPLE 382
-#define _GUARD_TOS_FLOAT 383
-#define _GUARD_TOS_INT 384
-#define _GUARD_TYPE_VERSION 385
+#define _GUARD_BOTH_FLOAT 367
+#define _GUARD_BOTH_INT 368
+#define _GUARD_BOTH_UNICODE 369
+#define _GUARD_BUILTINS_VERSION 370
+#define _GUARD_DORV_NO_DICT 371
+#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 372
+#define _GUARD_GLOBALS_VERSION 373
+#define _GUARD_IS_FALSE_POP 374
+#define _GUARD_IS_NONE_POP 375
+#define _GUARD_IS_NOT_NONE_POP 376
+#define _GUARD_IS_TRUE_POP 377
+#define _GUARD_KEYS_VERSION 378
+#define _GUARD_NOS_FLOAT 379
+#define _GUARD_NOS_INT 380
+#define _GUARD_NOT_EXHAUSTED_LIST 381
+#define _GUARD_NOT_EXHAUSTED_RANGE 382
+#define _GUARD_NOT_EXHAUSTED_TUPLE 383
+#define _GUARD_TOS_FLOAT 384
+#define _GUARD_TOS_INT 385
+#define _GUARD_TYPE_VERSION 386
#define _IMPORT_FROM IMPORT_FROM
#define _IMPORT_NAME IMPORT_NAME
-#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 386
-#define _INIT_CALL_PY_EXACT_ARGS 387
-#define _INIT_CALL_PY_EXACT_ARGS_0 388
-#define _INIT_CALL_PY_EXACT_ARGS_1 389
-#define _INIT_CALL_PY_EXACT_ARGS_2 390
-#define _INIT_CALL_PY_EXACT_ARGS_3 391
-#define _INIT_CALL_PY_EXACT_ARGS_4 392
+#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 387
+#define _INIT_CALL_PY_EXACT_ARGS 388
+#define _INIT_CALL_PY_EXACT_ARGS_0 389
+#define _INIT_CALL_PY_EXACT_ARGS_1 390
+#define _INIT_CALL_PY_EXACT_ARGS_2 391
+#define _INIT_CALL_PY_EXACT_ARGS_3 392
+#define _INIT_CALL_PY_EXACT_ARGS_4 393
#define _INSTRUMENTED_CALL_FUNCTION_EX INSTRUMENTED_CALL_FUNCTION_EX
#define _INSTRUMENTED_CALL_KW INSTRUMENTED_CALL_KW
#define _INSTRUMENTED_FOR_ITER INSTRUMENTED_FOR_ITER
#define _INSTRUMENTED_POP_JUMP_IF_NONE INSTRUMENTED_POP_JUMP_IF_NONE
#define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE INSTRUMENTED_POP_JUMP_IF_NOT_NONE
#define _INSTRUMENTED_POP_JUMP_IF_TRUE INSTRUMENTED_POP_JUMP_IF_TRUE
-#define _INTERNAL_INCREMENT_OPT_COUNTER 393
-#define _IS_NONE 394
+#define _INTERNAL_INCREMENT_OPT_COUNTER 394
+#define _IS_NONE 395
#define _IS_OP IS_OP
-#define _ITER_CHECK_LIST 395
-#define _ITER_CHECK_RANGE 396
-#define _ITER_CHECK_TUPLE 397
-#define _ITER_JUMP_LIST 398
-#define _ITER_JUMP_RANGE 399
-#define _ITER_JUMP_TUPLE 400
-#define _ITER_NEXT_LIST 401
-#define _ITER_NEXT_RANGE 402
-#define _ITER_NEXT_TUPLE 403
-#define _JUMP_TO_TOP 404
+#define _ITER_CHECK_LIST 396
+#define _ITER_CHECK_RANGE 397
+#define _ITER_CHECK_TUPLE 398
+#define _ITER_JUMP_LIST 399
+#define _ITER_JUMP_RANGE 400
+#define _ITER_JUMP_TUPLE 401
+#define _ITER_NEXT_LIST 402
+#define _ITER_NEXT_RANGE 403
+#define _ITER_NEXT_TUPLE 404
+#define _JUMP_TO_TOP 405
#define _LIST_APPEND LIST_APPEND
#define _LIST_EXTEND LIST_EXTEND
-#define _LOAD_ATTR 405
-#define _LOAD_ATTR_CLASS 406
-#define _LOAD_ATTR_CLASS_0 407
-#define _LOAD_ATTR_CLASS_1 408
+#define _LOAD_ATTR 406
+#define _LOAD_ATTR_CLASS 407
+#define _LOAD_ATTR_CLASS_0 408
+#define _LOAD_ATTR_CLASS_1 409
#define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN
-#define _LOAD_ATTR_INSTANCE_VALUE 409
-#define _LOAD_ATTR_INSTANCE_VALUE_0 410
-#define _LOAD_ATTR_INSTANCE_VALUE_1 411
-#define _LOAD_ATTR_METHOD_LAZY_DICT 412
-#define _LOAD_ATTR_METHOD_NO_DICT 413
-#define _LOAD_ATTR_METHOD_WITH_VALUES 414
-#define _LOAD_ATTR_MODULE 415
-#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 416
-#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 417
-#define _LOAD_ATTR_PROPERTY_FRAME 418
-#define _LOAD_ATTR_SLOT 419
-#define _LOAD_ATTR_SLOT_0 420
-#define _LOAD_ATTR_SLOT_1 421
-#define _LOAD_ATTR_WITH_HINT 422
+#define _LOAD_ATTR_INSTANCE_VALUE 410
+#define _LOAD_ATTR_INSTANCE_VALUE_0 411
+#define _LOAD_ATTR_INSTANCE_VALUE_1 412
+#define _LOAD_ATTR_METHOD_LAZY_DICT 413
+#define _LOAD_ATTR_METHOD_NO_DICT 414
+#define _LOAD_ATTR_METHOD_WITH_VALUES 415
+#define _LOAD_ATTR_MODULE 416
+#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 417
+#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 418
+#define _LOAD_ATTR_PROPERTY_FRAME 419
+#define _LOAD_ATTR_SLOT 420
+#define _LOAD_ATTR_SLOT_0 421
+#define _LOAD_ATTR_SLOT_1 422
+#define _LOAD_ATTR_WITH_HINT 423
#define _LOAD_BUILD_CLASS LOAD_BUILD_CLASS
#define _LOAD_COMMON_CONSTANT LOAD_COMMON_CONSTANT
#define _LOAD_CONST LOAD_CONST
-#define _LOAD_CONST_INLINE 423
-#define _LOAD_CONST_INLINE_BORROW 424
-#define _LOAD_CONST_INLINE_BORROW_WITH_NULL 425
-#define _LOAD_CONST_INLINE_WITH_NULL 426
+#define _LOAD_CONST_INLINE 424
+#define _LOAD_CONST_INLINE_BORROW 425
+#define _LOAD_CONST_INLINE_BORROW_WITH_NULL 426
+#define _LOAD_CONST_INLINE_WITH_NULL 427
#define _LOAD_DEREF LOAD_DEREF
-#define _LOAD_FAST 427
-#define _LOAD_FAST_0 428
-#define _LOAD_FAST_1 429
-#define _LOAD_FAST_2 430
-#define _LOAD_FAST_3 431
-#define _LOAD_FAST_4 432
-#define _LOAD_FAST_5 433
-#define _LOAD_FAST_6 434
-#define _LOAD_FAST_7 435
+#define _LOAD_FAST 428
+#define _LOAD_FAST_0 429
+#define _LOAD_FAST_1 430
+#define _LOAD_FAST_2 431
+#define _LOAD_FAST_3 432
+#define _LOAD_FAST_4 433
+#define _LOAD_FAST_5 434
+#define _LOAD_FAST_6 435
+#define _LOAD_FAST_7 436
#define _LOAD_FAST_AND_CLEAR LOAD_FAST_AND_CLEAR
#define _LOAD_FAST_CHECK LOAD_FAST_CHECK
#define _LOAD_FAST_LOAD_FAST LOAD_FAST_LOAD_FAST
#define _LOAD_FROM_DICT_OR_DEREF LOAD_FROM_DICT_OR_DEREF
#define _LOAD_FROM_DICT_OR_GLOBALS LOAD_FROM_DICT_OR_GLOBALS
-#define _LOAD_GLOBAL 436
-#define _LOAD_GLOBAL_BUILTINS 437
-#define _LOAD_GLOBAL_MODULE 438
+#define _LOAD_GLOBAL 437
+#define _LOAD_GLOBAL_BUILTINS 438
+#define _LOAD_GLOBAL_MODULE 439
#define _LOAD_LOCALS LOAD_LOCALS
#define _LOAD_NAME LOAD_NAME
#define _LOAD_SPECIAL LOAD_SPECIAL
#define _LOAD_SUPER_ATTR_ATTR LOAD_SUPER_ATTR_ATTR
#define _LOAD_SUPER_ATTR_METHOD LOAD_SUPER_ATTR_METHOD
+#define _MAKE_CALLARGS_A_TUPLE 440
#define _MAKE_CELL MAKE_CELL
#define _MAKE_FUNCTION MAKE_FUNCTION
-#define _MAKE_WARM 439
+#define _MAKE_WARM 441
#define _MAP_ADD MAP_ADD
#define _MATCH_CLASS MATCH_CLASS
#define _MATCH_KEYS MATCH_KEYS
#define _MATCH_MAPPING MATCH_MAPPING
#define _MATCH_SEQUENCE MATCH_SEQUENCE
-#define _MAYBE_EXPAND_METHOD 440
-#define _MONITOR_CALL 441
-#define _MONITOR_JUMP_BACKWARD 442
-#define _MONITOR_RESUME 443
+#define _MAYBE_EXPAND_METHOD 442
+#define _MAYBE_EXPAND_METHOD_KW 443
+#define _MONITOR_CALL 444
+#define _MONITOR_JUMP_BACKWARD 445
+#define _MONITOR_RESUME 446
#define _NOP NOP
#define _POP_EXCEPT POP_EXCEPT
-#define _POP_JUMP_IF_FALSE 444
-#define _POP_JUMP_IF_TRUE 445
+#define _POP_JUMP_IF_FALSE 447
+#define _POP_JUMP_IF_TRUE 448
#define _POP_TOP POP_TOP
-#define _POP_TOP_LOAD_CONST_INLINE_BORROW 446
+#define _POP_TOP_LOAD_CONST_INLINE_BORROW 449
#define _PUSH_EXC_INFO PUSH_EXC_INFO
-#define _PUSH_FRAME 447
+#define _PUSH_FRAME 450
#define _PUSH_NULL PUSH_NULL
-#define _PY_FRAME_GENERAL 448
-#define _PY_FRAME_KW 449
-#define _QUICKEN_RESUME 450
-#define _REPLACE_WITH_TRUE 451
+#define _PY_FRAME_GENERAL 451
+#define _PY_FRAME_KW 452
+#define _QUICKEN_RESUME 453
+#define _REPLACE_WITH_TRUE 454
#define _RESUME_CHECK RESUME_CHECK
#define _RETURN_GENERATOR RETURN_GENERATOR
#define _RETURN_VALUE RETURN_VALUE
-#define _SAVE_RETURN_OFFSET 452
-#define _SEND 453
-#define _SEND_GEN_FRAME 454
+#define _SAVE_RETURN_OFFSET 455
+#define _SEND 456
+#define _SEND_GEN_FRAME 457
#define _SETUP_ANNOTATIONS SETUP_ANNOTATIONS
#define _SET_ADD SET_ADD
#define _SET_FUNCTION_ATTRIBUTE SET_FUNCTION_ATTRIBUTE
#define _SET_UPDATE SET_UPDATE
-#define _START_EXECUTOR 455
-#define _STORE_ATTR 456
-#define _STORE_ATTR_INSTANCE_VALUE 457
-#define _STORE_ATTR_SLOT 458
-#define _STORE_ATTR_WITH_HINT 459
+#define _START_EXECUTOR 458
+#define _STORE_ATTR 459
+#define _STORE_ATTR_INSTANCE_VALUE 460
+#define _STORE_ATTR_SLOT 461
+#define _STORE_ATTR_WITH_HINT 462
#define _STORE_DEREF STORE_DEREF
-#define _STORE_FAST 460
-#define _STORE_FAST_0 461
-#define _STORE_FAST_1 462
-#define _STORE_FAST_2 463
-#define _STORE_FAST_3 464
-#define _STORE_FAST_4 465
-#define _STORE_FAST_5 466
-#define _STORE_FAST_6 467
-#define _STORE_FAST_7 468
+#define _STORE_FAST 463
+#define _STORE_FAST_0 464
+#define _STORE_FAST_1 465
+#define _STORE_FAST_2 466
+#define _STORE_FAST_3 467
+#define _STORE_FAST_4 468
+#define _STORE_FAST_5 469
+#define _STORE_FAST_6 470
+#define _STORE_FAST_7 471
#define _STORE_FAST_LOAD_FAST STORE_FAST_LOAD_FAST
#define _STORE_FAST_STORE_FAST STORE_FAST_STORE_FAST
#define _STORE_GLOBAL STORE_GLOBAL
#define _STORE_NAME STORE_NAME
-#define _STORE_SLICE 469
-#define _STORE_SUBSCR 470
+#define _STORE_SLICE 472
+#define _STORE_SUBSCR 473
#define _STORE_SUBSCR_DICT STORE_SUBSCR_DICT
#define _STORE_SUBSCR_LIST_INT STORE_SUBSCR_LIST_INT
#define _SWAP SWAP
-#define _TIER2_RESUME_CHECK 471
-#define _TO_BOOL 472
+#define _TIER2_RESUME_CHECK 474
+#define _TO_BOOL 475
#define _TO_BOOL_BOOL TO_BOOL_BOOL
#define _TO_BOOL_INT TO_BOOL_INT
#define _TO_BOOL_LIST TO_BOOL_LIST
#define _UNARY_NEGATIVE UNARY_NEGATIVE
#define _UNARY_NOT UNARY_NOT
#define _UNPACK_EX UNPACK_EX
-#define _UNPACK_SEQUENCE 473
+#define _UNPACK_SEQUENCE 476
#define _UNPACK_SEQUENCE_LIST UNPACK_SEQUENCE_LIST
#define _UNPACK_SEQUENCE_TUPLE UNPACK_SEQUENCE_TUPLE
#define _UNPACK_SEQUENCE_TWO_TUPLE UNPACK_SEQUENCE_TWO_TUPLE
#define _WITH_EXCEPT_START WITH_EXCEPT_START
#define _YIELD_VALUE YIELD_VALUE
-#define __DO_CALL_FUNCTION_EX _DO_CALL_FUNCTION_EX
-#define MAX_UOP_ID 473
+#define MAX_UOP_ID 476
#ifdef __cplusplus
}
[_UNARY_NOT] = HAS_PURE_FLAG,
[_TO_BOOL] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_TO_BOOL_BOOL] = HAS_EXIT_FLAG,
- [_TO_BOOL_INT] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG,
+ [_TO_BOOL_INT] = HAS_EXIT_FLAG,
[_TO_BOOL_LIST] = HAS_EXIT_FLAG,
[_TO_BOOL_NONE] = HAS_EXIT_FLAG,
- [_TO_BOOL_STR] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG,
+ [_TO_BOOL_STR] = HAS_EXIT_FLAG,
[_REPLACE_WITH_TRUE] = 0,
[_UNARY_INVERT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_GUARD_BOTH_INT] = HAS_EXIT_FLAG,
[_BINARY_OP_SUBTRACT_FLOAT] = HAS_PURE_FLAG,
[_GUARD_BOTH_UNICODE] = HAS_EXIT_FLAG,
[_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_PURE_FLAG,
- [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
+ [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG,
[_BINARY_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_STORE_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_BINARY_SUBSCR_STR_INT] = HAS_DEOPT_FLAG,
[_BINARY_SUBSCR_TUPLE_INT] = HAS_DEOPT_FLAG,
[_BINARY_SUBSCR_DICT] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
- [_BINARY_SUBSCR_CHECK_FUNC] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG,
+ [_BINARY_SUBSCR_CHECK_FUNC] = HAS_DEOPT_FLAG,
[_BINARY_SUBSCR_INIT_CALL] = 0,
[_LIST_APPEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG,
[_SET_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_GET_AWAITABLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_SEND_GEN_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG,
- [_YIELD_VALUE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG,
+ [_YIELD_VALUE] = HAS_ARG_FLAG,
[_POP_EXCEPT] = HAS_ESCAPES_FLAG,
[_LOAD_COMMON_CONSTANT] = HAS_ARG_FLAG,
[_LOAD_BUILD_CLASS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_LOAD_ATTR_CLASS_0] = 0,
[_LOAD_ATTR_CLASS_1] = 0,
[_LOAD_ATTR_CLASS] = HAS_ARG_FLAG | HAS_OPARG_AND_1_FLAG,
- [_LOAD_ATTR_PROPERTY_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG,
+ [_LOAD_ATTR_PROPERTY_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG,
[_GUARD_DORV_NO_DICT] = HAS_EXIT_FLAG,
[_STORE_ATTR_INSTANCE_VALUE] = 0,
[_STORE_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG,
[_CALL_TYPE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG,
[_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
- [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
+ [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG,
[_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_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_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = 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,
[_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_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,
[_CHECK_IS_NOT_PY_CALLABLE_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG,
[_CALL_KW_NON_PY] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
- [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
- [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG,
- [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
+ [_MAKE_CALLARGS_A_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
+ [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
+ [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG,
+ [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG,
- [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG,
+ [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_FORMAT_WITH_SPEC] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_COPY] = HAS_ARG_FLAG | HAS_PURE_FLAG,
[_LOAD_SPECIAL] = "_LOAD_SPECIAL",
[_LOAD_SUPER_ATTR_ATTR] = "_LOAD_SUPER_ATTR_ATTR",
[_LOAD_SUPER_ATTR_METHOD] = "_LOAD_SUPER_ATTR_METHOD",
+ [_MAKE_CALLARGS_A_TUPLE] = "_MAKE_CALLARGS_A_TUPLE",
[_MAKE_CELL] = "_MAKE_CELL",
[_MAKE_FUNCTION] = "_MAKE_FUNCTION",
[_MAKE_WARM] = "_MAKE_WARM",
[_MATCH_MAPPING] = "_MATCH_MAPPING",
[_MATCH_SEQUENCE] = "_MATCH_SEQUENCE",
[_MAYBE_EXPAND_METHOD] = "_MAYBE_EXPAND_METHOD",
+ [_MAYBE_EXPAND_METHOD_KW] = "_MAYBE_EXPAND_METHOD_KW",
[_NOP] = "_NOP",
[_POP_EXCEPT] = "_POP_EXCEPT",
[_POP_TOP] = "_POP_TOP",
return 2 + oparg;
case _CALL_METHOD_DESCRIPTOR_FAST:
return 2 + oparg;
+ case _MAYBE_EXPAND_METHOD_KW:
+ return 3 + oparg;
case _PY_FRAME_KW:
return 3 + oparg;
case _CHECK_FUNCTION_VERSION_KW:
return 3 + oparg;
case _CALL_KW_NON_PY:
return 3 + oparg;
+ case _MAKE_CALLARGS_A_TUPLE:
+ return 3 + (oparg & 1);
case _MAKE_FUNCTION:
return 1;
case _SET_FUNCTION_ATTRIBUTE:
#define UNPACK_EX 113
#define UNPACK_SEQUENCE 114
#define YIELD_VALUE 115
-#define _DO_CALL_FUNCTION_EX 116
#define RESUME 149
#define BINARY_OP_ADD_FLOAT 150
#define BINARY_OP_ADD_INT 151
'UNPACK_EX': 113,
'UNPACK_SEQUENCE': 114,
'YIELD_VALUE': 115,
- '_DO_CALL_FUNCTION_EX': 116,
'INSTRUMENTED_END_FOR': 236,
'INSTRUMENTED_END_SEND': 237,
'INSTRUMENTED_LOAD_SUPER_ATTR': 238,
# can't use assertRaises because that clears frames
exc = excs.exceptions[0]
self.assertIsNotNone(exc)
- self.assertListEqual(gc.get_referrers(exc), [])
-
- asyncio.run(main())
+ self.assertListEqual(gc.get_referrers(exc), [main_coro])
+ main_coro = main()
+ asyncio.run(main_coro)
if __name__ == '__main__':
stack.pop(y)
stack.pop(x)
for out in outputs:
- stack.push(Local.local(out))
+ stack.push(Local.undefined(out))
self.assertEqual(stack.base_offset.to_c(), "-1 - oparg - oparg*2")
self.assertEqual(stack.top_offset.to_c(), "1 - oparg - oparg*2 + oparg*4")
def test_inst_no_args(self):
input = """
inst(OP, (--)) {
- spam();
+ SPAM();
}
"""
output = """
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(OP);
- spam();
+ SPAM();
DISPATCH();
}
"""
def test_inst_one_pop(self):
input = """
inst(OP, (value --)) {
- spam(value);
+ SPAM(value);
+ DEAD(value);
}
"""
output = """
INSTRUCTION_STATS(OP);
_PyStackRef value;
value = stack_pointer[-1];
- spam(value);
+ SPAM(value);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
def test_inst_one_push(self):
input = """
inst(OP, (-- res)) {
- res = spam();
+ res = SPAM();
}
"""
output = """
next_instr += 1;
INSTRUCTION_STATS(OP);
_PyStackRef res;
- res = spam();
+ res = SPAM();
stack_pointer[0] = res;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
def test_inst_one_push_one_pop(self):
input = """
inst(OP, (value -- res)) {
- res = spam(value);
+ res = SPAM(value);
+ DEAD(value);
}
"""
output = """
_PyStackRef value;
_PyStackRef res;
value = stack_pointer[-1];
- res = spam(value);
+ res = SPAM(value);
stack_pointer[-1] = res;
DISPATCH();
}
def test_binary_op(self):
input = """
inst(OP, (left, right -- res)) {
- res = spam(left, right);
+ res = SPAM(left, right);
+ INPUTS_DEAD();
+
}
"""
output = """
_PyStackRef res;
right = stack_pointer[-1];
left = stack_pointer[-2];
- res = spam(left, right);
+ res = SPAM(left, right);
stack_pointer[-2] = res;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
def test_overlap(self):
input = """
inst(OP, (left, right -- left, result)) {
- result = spam(left, right);
+ result = SPAM(left, right);
+ INPUTS_DEAD();
}
"""
output = """
_PyStackRef result;
right = stack_pointer[-1];
left = stack_pointer[-2];
- result = spam(left, right);
+ result = SPAM(left, right);
stack_pointer[-1] = result;
DISPATCH();
}
def test_predictions(self):
input = """
- inst(OP1, (arg -- rest)) {
+ inst(OP1, (arg -- res)) {
+ res = Py_None;
}
inst(OP3, (arg -- res)) {
DEOPT_IF(xxx);
next_instr += 1;
INSTRUCTION_STATS(OP1);
PREDICTED(OP1);
- stack_pointer[-1] = rest;
+ _PyStackRef res;
+ res = Py_None;
+ stack_pointer[-1] = res;
DISPATCH();
}
"""
self.run_cases_test(input, output)
+ def test_sync_sp(self):
+ input = """
+ inst(A, (arg -- res)) {
+ SYNC_SP();
+ escaping_call();
+ res = Py_None;
+ }
+ inst(B, (arg -- res)) {
+ res = Py_None;
+ SYNC_SP();
+ escaping_call();
+ }
+ """
+ output = """
+ TARGET(A) {
+ frame->instr_ptr = next_instr;
+ next_instr += 1;
+ INSTRUCTION_STATS(A);
+ _PyStackRef res;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ escaping_call();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ res = Py_None;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
+ DISPATCH();
+ }
+
+ TARGET(B) {
+ frame->instr_ptr = next_instr;
+ next_instr += 1;
+ INSTRUCTION_STATS(B);
+ _PyStackRef res;
+ res = Py_None;
+ stack_pointer[-1] = res;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ escaping_call();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ DISPATCH();
+ }
+ """
+ self.run_cases_test(input, output)
+
+
+ def test_pep7_condition(self):
+ input = """
+ inst(OP, (arg1 -- out)) {
+ if (arg1)
+ out = 0;
+ else {
+ out = 1;
+ }
+ }
+ """
+ output = ""
+ with self.assertRaises(SyntaxError):
+ self.run_cases_test(input, output)
+
def test_error_if_plain(self):
input = """
inst(OP, (--)) {
def test_error_if_pop(self):
input = """
inst(OP, (left, right -- res)) {
- res = spam(left, right);
+ SPAM(left, right);
+ INPUTS_DEAD();
ERROR_IF(cond, label);
+ res = 0;
}
"""
output = """
_PyStackRef res;
right = stack_pointer[-1];
left = stack_pointer[-2];
- res = spam(left, right);
+ SPAM(left, right);
+ if (cond) goto pop_2_label;
+ res = 0;
+ stack_pointer[-2] = res;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ DISPATCH();
+ }
+ """
+ self.run_cases_test(input, output)
+
+ def test_error_if_pop_with_result(self):
+ input = """
+ inst(OP, (left, right -- res)) {
+ res = SPAM(left, right);
+ INPUTS_DEAD();
+ ERROR_IF(cond, label);
+ }
+ """
+ output = """
+ TARGET(OP) {
+ frame->instr_ptr = next_instr;
+ next_instr += 1;
+ INSTRUCTION_STATS(OP);
+ _PyStackRef left;
+ _PyStackRef right;
+ _PyStackRef res;
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
+ res = SPAM(left, right);
if (cond) goto pop_2_label;
stack_pointer[-2] = res;
stack_pointer += -1;
}
op(OP2, (extra/2, arg2, left, right -- res)) {
res = op2(arg2, left, right);
+ INPUTS_DEAD();
}
macro(OP) = OP1 + cache/2 + OP2;
inst(OP3, (unused/5, arg2, left, right -- res)) {
res = op3(arg2, left, right);
+ INPUTS_DEAD();
}
family(OP, INLINE_CACHE_ENTRIES_OP) = { OP3 };
"""
_PyStackRef arg2;
_PyStackRef res;
// _OP1
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
op1(left, right);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
/* Skip 2 cache entries */
// OP2
- arg2 = stack_pointer[-3];
{
+ arg2 = stack_pointer[-3];
uint32_t extra = read_u32(&this_instr[4].cache);
(void)extra;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = op2(arg2, left, right);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
stack_pointer[-3] = res;
stack_pointer += -2;
left = stack_pointer[-2];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
op1(left, right);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
right = stack_pointer[-1];
left = stack_pointer[-2];
arg2 = stack_pointer[-3];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = op3(arg2, left, right);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer[-3] = res;
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
def test_unused_caches(self):
input = """
inst(OP, (unused/1, unused/2 --)) {
- body();
+ body;
}
"""
output = """
INSTRUCTION_STATS(OP);
/* Skip 1 cache entry */
/* Skip 2 cache entries */
- body();
+ body;
DISPATCH();
}
"""
def test_array_input(self):
input = """
inst(OP, (below, values[oparg*2], above --)) {
- spam(values, oparg);
+ SPAM(values, oparg);
}
"""
output = """
INSTRUCTION_STATS(OP);
_PyStackRef *values;
values = &stack_pointer[-1 - oparg*2];
- spam(values, oparg);
+ SPAM(values, oparg);
stack_pointer += -2 - oparg*2;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
def test_array_output(self):
input = """
inst(OP, (unused, unused -- below, values[oparg*3], above)) {
- spam(values, oparg);
+ SPAM(values, oparg);
+ below = 0;
+ above = 0;
}
"""
output = """
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(OP);
+ _PyStackRef below;
_PyStackRef *values;
+ _PyStackRef above;
values = &stack_pointer[-1];
- spam(values, oparg);
+ SPAM(values, oparg);
+ below = 0;
+ above = 0;
stack_pointer[-2] = below;
stack_pointer[-1 + oparg*3] = above;
stack_pointer += oparg*3;
def test_array_input_output(self):
input = """
inst(OP, (values[oparg] -- values[oparg], above)) {
- spam(values, oparg);
+ SPAM(values, oparg);
+ above = 0;
}
"""
output = """
next_instr += 1;
INSTRUCTION_STATS(OP);
_PyStackRef *values;
+ _PyStackRef above;
values = &stack_pointer[-oparg];
- spam(values, oparg);
+ SPAM(values, oparg);
+ above = 0;
stack_pointer[0] = above;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
def test_cond_effect(self):
input = """
inst(OP, (aa, input if ((oparg & 1) == 1), cc -- xx, output if (oparg & 2), zz)) {
- output = spam(oparg, aa, cc, input);
+ output = SPAM(oparg, aa, cc, input);
+ INPUTS_DEAD();
+ xx = 0;
+ zz = 0;
}
"""
output = """
_PyStackRef aa;
_PyStackRef input = PyStackRef_NULL;
_PyStackRef cc;
+ _PyStackRef xx;
_PyStackRef output = PyStackRef_NULL;
+ _PyStackRef zz;
cc = stack_pointer[-1];
if ((oparg & 1) == 1) { input = stack_pointer[-1 - (((oparg & 1) == 1) ? 1 : 0)]; }
aa = stack_pointer[-2 - (((oparg & 1) == 1) ? 1 : 0)];
- output = spam(oparg, aa, cc, input);
+ output = SPAM(oparg, aa, cc, input);
+ xx = 0;
+ zz = 0;
stack_pointer[-2 - (((oparg & 1) == 1) ? 1 : 0)] = xx;
if (oparg & 2) stack_pointer[-1 - (((oparg & 1) == 1) ? 1 : 0)] = output;
stack_pointer[-1 - (((oparg & 1) == 1) ? 1 : 0) + ((oparg & 2) ? 1 : 0)] = zz;
def test_macro_cond_effect(self):
input = """
op(A, (left, middle, right --)) {
- use(left, middle, right);
+ USE(left, middle, right);
+ INPUTS_DEAD();
}
op(B, (-- deep, extra if (oparg), res)) {
+ deep = -1;
res = 0;
extra = 1;
+ INPUTS_DEAD();
}
macro(M) = A + B;
"""
_PyStackRef left;
_PyStackRef middle;
_PyStackRef right;
+ _PyStackRef deep;
_PyStackRef extra = PyStackRef_NULL;
_PyStackRef res;
// A
- right = stack_pointer[-1];
- middle = stack_pointer[-2];
- left = stack_pointer[-3];
{
- use(left, middle, right);
+ right = stack_pointer[-1];
+ middle = stack_pointer[-2];
+ left = stack_pointer[-3];
+ USE(left, middle, right);
}
// B
{
+ deep = -1;
res = 0;
extra = 1;
}
def test_macro_push_push(self):
input = """
op(A, (-- val1)) {
- val1 = spam();
+ val1 = SPAM();
}
op(B, (-- val2)) {
- val2 = spam();
+ val2 = SPAM();
}
macro(M) = A + B;
"""
_PyStackRef val2;
// A
{
- val1 = spam();
+ val1 = SPAM();
}
// B
{
- val2 = spam();
+ val2 = SPAM();
}
stack_pointer[0] = val1;
stack_pointer[1] = val2;
def test_override_inst(self):
input = """
inst(OP, (--)) {
- spam();
+ spam;
}
override inst(OP, (--)) {
- ham();
+ ham;
}
"""
output = """
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(OP);
- ham();
+ ham;
DISPATCH();
}
"""
def test_override_op(self):
input = """
op(OP, (--)) {
- spam();
+ spam;
}
macro(M) = OP;
override op(OP, (--)) {
- ham();
+ ham;
}
"""
output = """
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(M);
- ham();
+ ham;
DISPATCH();
}
"""
def test_annotated_inst(self):
input = """
pure inst(OP, (--)) {
- ham();
+ ham;
}
"""
output = """
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(OP);
- ham();
+ ham;
DISPATCH();
}
"""
def test_annotated_op(self):
input = """
pure op(OP, (--)) {
- spam();
+ SPAM();
}
macro(M) = OP;
"""
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(M);
- spam();
+ SPAM();
DISPATCH();
}
"""
input = """
pure register specializing op(OP, (--)) {
- spam();
+ SPAM();
}
macro(M) = OP;
"""
}
"""
output = ""
- with self.assertRaises(Exception):
+ with self.assertRaises(SyntaxError):
self.run_cases_test(input, output)
def test_array_of_one(self):
input = """
inst(OP, (arg: _PyStackRef * -- out)) {
out = *arg;
+ DEAD(arg);
}
"""
output = """
def test_used_unused_used(self):
input = """
op(FIRST, (w -- w)) {
- use(w);
+ USE(w);
}
op(SECOND, (x -- x)) {
}
op(THIRD, (y -- y)) {
- use(y);
+ USE(y);
}
macro(TEST) = FIRST + SECOND + THIRD;
_PyStackRef w;
_PyStackRef y;
// FIRST
- w = stack_pointer[-1];
{
- use(w);
+ w = stack_pointer[-1];
+ USE(w);
}
// SECOND
{
}
// THIRD
- y = w;
{
- use(y);
+ y = w;
+ USE(y);
}
DISPATCH();
}
}
op(SECOND, (x -- x)) {
- use(x);
+ USE(x);
}
op(THIRD, (y -- y)) {
- use(y);
+ USE(y);
}
macro(TEST) = FIRST + SECOND + THIRD;
{
}
// SECOND
- x = stack_pointer[-1];
{
- use(x);
+ x = stack_pointer[-1];
+ USE(x);
}
// THIRD
- y = x;
{
- use(y);
+ y = x;
+ USE(y);
}
DISPATCH();
}
}
op(SECOND, (a, b -- )) {
- use(a, b);
+ USE(a, b);
+ INPUTS_DEAD();
}
macro(TEST) = FIRST + flush + SECOND;
stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
// SECOND
- b = stack_pointer[-1];
- a = stack_pointer[-2];
{
- use(a, b);
+ USE(a, b);
}
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
input = """
op(FIRST, (x, y -- a, b)) {
a = x;
+ DEAD(x);
b = y;
+ DEAD(y);
}
op(SECOND, (a, b -- a, b)) {
}
op(THIRD, (j, k --)) {
- j,k; // Mark j and k as used
+ INPUTS_DEAD(); // Mark j and k as used
ERROR_IF(cond, error);
}
_PyStackRef y;
_PyStackRef a;
_PyStackRef b;
- _PyStackRef j;
- _PyStackRef k;
// FIRST
- y = stack_pointer[-1];
- x = stack_pointer[-2];
{
+ y = stack_pointer[-1];
+ x = stack_pointer[-2];
a = x;
b = y;
}
{
}
// THIRD
- k = b;
- j = a;
{
- j,k; // Mark j and k as used
+ // Mark j and k as used
if (cond) goto pop_2_error;
}
stack_pointer += -2;
b = 1;
if (cond) {
stack_pointer[0] = a;
- stack_pointer += 1;
+ stack_pointer[1] = b;
+ stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
goto error;
}
with self.assertRaises(SyntaxError):
self.run_cases_test(input, output)
+ def test_stack_save_reload(self):
+
+ input = """
+ inst(BALANCED, ( -- )) {
+ SAVE_STACK();
+ RELOAD_STACK();
+ }
+ """
+
+ output = """
+ TARGET(BALANCED) {
+ frame->instr_ptr = next_instr;
+ next_instr += 1;
+ INSTRUCTION_STATS(BALANCED);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ DISPATCH();
+ }
+ """
+ self.run_cases_test(input, output)
+
+ def test_stack_reload_only(self):
+
+ input = """
+ inst(BALANCED, ( -- )) {
+ RELOAD_STACK();
+ }
+ """
+
+ output = """
+ TARGET(BALANCED) {
+ frame->instr_ptr = next_instr;
+ next_instr += 1;
+ INSTRUCTION_STATS(BALANCED);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ DISPATCH();
+ }
+ """
+ with self.assertRaises(SyntaxError):
+ self.run_cases_test(input, output)
+
+ def test_stack_save_only(self):
+
+ input = """
+ inst(BALANCED, ( -- )) {
+ SAVE_STACK();
+ }
+ """
+
+ output = """
+ TARGET(BALANCED) {
+ frame->instr_ptr = next_instr;
+ next_instr += 1;
+ INSTRUCTION_STATS(BALANCED);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ DISPATCH();
+ }
+ """
+ with self.assertRaises(SyntaxError):
+ self.run_cases_test(input, output)
+
class TestGeneratedAbstractCases(unittest.TestCase):
def setUp(self) -> None:
def test_overridden_abstract(self):
input = """
pure op(OP, (--)) {
- spam();
+ SPAM();
}
"""
input2 = """
def test_overridden_abstract_args(self):
input = """
pure op(OP, (arg1 -- out)) {
- spam();
+ out = SPAM(arg1);
}
op(OP2, (arg1 -- out)) {
- eggs();
+ out = EGGS(arg1);
}
"""
input2 = """
op(OP, (arg1 -- out)) {
- eggs();
+ out = EGGS(arg1);
}
"""
output = """
case OP: {
_Py_UopsSymbol *arg1;
_Py_UopsSymbol *out;
- eggs();
+ arg1 = stack_pointer[-1];
+ out = EGGS(arg1);
stack_pointer[-1] = out;
break;
}
def test_no_overridden_case(self):
input = """
pure op(OP, (arg1 -- out)) {
- spam();
+ out = SPAM(arg1);
}
pure op(OP2, (arg1 -- out)) {
"""
input2 = """
pure op(OP2, (arg1 -- out)) {
+ out = NULL;
}
"""
output = """
}
case OP2: {
- _Py_UopsSymbol *arg1;
_Py_UopsSymbol *out;
+ out = NULL;
stack_pointer[-1] = out;
break;
}
def test_missing_override_failure(self):
input = """
pure op(OP, (arg1 -- out)) {
- spam();
+ SPAM();
}
"""
input2 = """
def check_events(self, func, expected, tool=TEST_TOOL, recorders=(ExceptionRecorder,)):
events = self.get_events(func, tool, recorders)
- if events != expected:
- print(events, file = sys.stderr)
self.assertEqual(events, expected)
def check_balanced(self, func, recorders):
op(_CHECK_PERIODIC, (--)) {
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
int err = _Py_HandlePending(tstate);
ERROR_IF(err != 0, error);
}
op(_MONITOR_RESUME, (--)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation(
tstate, oparg > 0, frame, this_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
ERROR_IF(err, error);
if (frame->instr_ptr != this_instr) {
/* Instrumentation has jumped */
replicate(8) inst(STORE_FAST, (value --)) {
SETLOCAL(oparg, value);
+ DEAD(value);
}
pseudo(STORE_FAST_MAYBE_NULL, (unused --)) = {
uint32_t oparg1 = oparg >> 4;
uint32_t oparg2 = oparg & 15;
SETLOCAL(oparg1, value1);
+ DEAD(value1);
value2 = PyStackRef_DUP(GETLOCAL(oparg2));
}
uint32_t oparg1 = oparg >> 4;
uint32_t oparg2 = oparg & 15;
SETLOCAL(oparg1, value1);
+ DEAD(value1);
SETLOCAL(oparg2, value2);
+ DEAD(value2);
}
pure inst(POP_TOP, (value --)) {
DECREF_INPUTS();
}
- pure inst(END_SEND, (receiver, value -- value)) {
+ pure inst(END_SEND, (receiver, value -- val)) {
(void)receiver;
+ val = value;
+ DEAD(value);
PyStackRef_CLOSE(receiver);
}
- tier1 inst(INSTRUMENTED_END_SEND, (receiver, value -- value)) {
+ tier1 inst(INSTRUMENTED_END_SEND, (receiver, value -- val)) {
PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);
if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) {
int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));
ERROR_NO_POP();
}
}
+ val = value;
+ DEAD(value);
PyStackRef_CLOSE(receiver);
}
assert(PyStackRef_BoolCheck(value));
res = PyStackRef_Is(value, PyStackRef_False)
? PyStackRef_True : PyStackRef_False;
+ DEAD(value);
}
family(TO_BOOL, INLINE_CACHE_ENTRIES_TO_BOOL) = {
STAT_INC(TO_BOOL, hit);
if (_PyLong_IsZero((PyLongObject *)value_o)) {
assert(_Py_IsImmortalLoose(value_o));
+ DEAD(value);
res = PyStackRef_False;
}
else {
inst(TO_BOOL_NONE, (unused/1, unused/2, value -- res)) {
// This one is a bit weird, because we expect *some* failures:
EXIT_IF(!PyStackRef_Is(value, PyStackRef_None));
+ DEAD(value);
STAT_INC(TO_BOOL, hit);
res = PyStackRef_False;
}
STAT_INC(TO_BOOL, hit);
if (value_o == &_Py_STR(empty)) {
assert(_Py_IsImmortalLoose(value_o));
+ DEAD(value);
res = PyStackRef_False;
}
else {
PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);
_Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);
_Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);
+ INPUTS_DEAD();
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);
_Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);
_Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);
+ INPUTS_DEAD();
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
STAT_INC(BINARY_OP, hit);
PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
_Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);
- _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);;
+ _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);
+ INPUTS_DEAD();
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o;
DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o);
+ INPUTS_DEAD();
res = PyStackRef_FromPyObjectSteal(res_o);
}
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o;
DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o);
+ INPUTS_DEAD();
res = PyStackRef_FromPyObjectSteal(res_o);
}
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o;
DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o);
+ INPUTS_DEAD();
res = PyStackRef_FromPyObjectSteal(res_o);
}
PyObject *res_o = PyUnicode_Concat(left_o, right_o);
_Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc);
_Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);
+ INPUTS_DEAD();
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
*/
assert(Py_REFCNT(left_o) >= 2);
_Py_DECREF_NO_DEALLOC(left_o);
+ DEAD(left);
PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local);
PyUnicode_Append(&temp, right_o);
*target_local = PyStackRef_FromPyObjectSteal(temp);
_Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);
+ DEAD(right);
ERROR_IF(PyStackRef_IsNull(*target_local), error);
#if TIER_ONE
// The STORE_FAST is already done. This is done here in tier one,
};
specializing op(_SPECIALIZE_BINARY_SUBSCR, (counter/1, container, sub -- container, sub)) {
+ assert(frame->stackpointer == NULL);
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
assert(res_o != NULL);
Py_INCREF(res_o);
_Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
+ DEAD(sub_st);
PyStackRef_CLOSE(list_st);
res = PyStackRef_FromPyObjectSteal(res_o);
}
STAT_INC(BINARY_SUBSCR, hit);
PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c];
_Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
+ DEAD(sub_st);
PyStackRef_CLOSE(str_st);
res = PyStackRef_FromPyObjectSteal(res_o);
}
assert(res_o != NULL);
Py_INCREF(res_o);
_Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
+ DEAD(sub_st);
PyStackRef_CLOSE(tuple_st);
res = PyStackRef_FromPyObjectSteal(res_o);
}
PyHeapTypeObject *ht = (PyHeapTypeObject *)tp;
PyObject *getitem = ht->_spec_cache.getitem;
new_frame = _PyFrame_PushUnchecked(tstate, PyStackRef_FromPyObjectNew(getitem), 2, frame);
- SYNC_SP();
new_frame->localsplus[0] = container;
new_frame->localsplus[1] = sub;
+ INPUTS_DEAD();
frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
}
_PUSH_FRAME;
inst(LIST_APPEND, (list, unused[oparg-1], v -- list, unused[oparg-1])) {
- ERROR_IF(_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
- PyStackRef_AsPyObjectSteal(v)) < 0, error);
+ int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
+ PyStackRef_AsPyObjectSteal(v));
+ ERROR_IF(err < 0, error);
}
inst(SET_ADD, (set, unused[oparg-1], v -- set, unused[oparg-1])) {
assert(old_value != NULL);
Py_DECREF(old_value);
_Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
+ DEAD(sub_st);
PyStackRef_CLOSE(list_st);
}
}
tier1 inst(RAISE_VARARGS, (args[oparg] -- )) {
- PyObject *cause = NULL, *exc = NULL;
- switch (oparg) {
- case 2:
- cause = PyStackRef_AsPyObjectSteal(args[1]);
- _Py_FALLTHROUGH;
- case 1:
- exc = PyStackRef_AsPyObjectSteal(args[0]);
- _Py_FALLTHROUGH;
- case 0:
- if (do_raise(tstate, exc, cause)) {
- assert(oparg == 0);
- monitor_reraise(tstate, frame, this_instr);
- goto exception_unwind;
- }
- break;
- default:
- _PyErr_SetString(tstate, PyExc_SystemError,
- "bad RAISE_VARARGS oparg");
- break;
+ assert(oparg < 3);
+ PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL;
+ PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL;
+ int err = do_raise(tstate, exc, cause);
+ if (err) {
+ assert(oparg == 0);
+ monitor_reraise(tstate, frame, this_instr);
+ goto exception_unwind;
}
ERROR_IF(true, error);
}
#if TIER_ONE
assert(frame != &entry_frame);
#endif
- SYNC_SP();
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef temp = retval;
+ DEAD(retval);
+ SAVE_STACK();
assert(EMPTY());
_Py_LeaveRecursiveCallPy(tstate);
// GH-99729: We need to unlink the frame *before* clearing it:
_PyInterpreterFrame *dying = frame;
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
- LOAD_SP();
+ RELOAD_STACK();
LOAD_IP(frame->return_offset);
- res = retval;
+ res = temp;
LLTRACE_RESUME_FRAME();
}
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_RETURN,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
- if (err) ERROR_NO_POP();
+ ERROR_IF(err, error);
}
macro(INSTRUMENTED_RETURN_VALUE) =
JUMPBY(oparg);
}
else {
- ERROR_NO_POP();
+ DECREF_INPUTS();
+ ERROR_IF(true, error);
}
}
PyStackRef_CLOSE(v);
STAT_INC(SEND, hit);
gen_frame = &gen->gi_iframe;
_PyFrame_StackPush(gen_frame, v);
+ DEAD(v);
gen->gi_frame_state = FRAME_EXECUTING;
gen->gi_exc_state.previous_item = tstate->exc_info;
tstate->exc_info = &gen->gi_exc_state;
assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1);
assert(oparg == 0 || oparg == 1);
gen->gi_frame_state = FRAME_SUSPENDED + oparg;
- SYNC_SP();
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef temp = retval;
+ DEAD(retval);
+ SAVE_STACK();
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
_Py_LeaveRecursiveCallPy(tstate);
_PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT ||
_PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR);
#endif
+ RELOAD_STACK();
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
- LOAD_SP();
- value = retval;
+ value = temp;
LLTRACE_RESUME_FRAME();
}
tier1 op(_YIELD_VALUE_EVENT, (val -- val)) {
- SAVE_SP();
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_YIELD,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
- LOAD_SP();
- if (err) ERROR_NO_POP();
+ if (err) {
+ ERROR_NO_POP();
+ }
if (frame->instr_ptr != this_instr) {
next_instr = frame->instr_ptr;
DISPATCH();
}
tier1 inst(RERAISE, (values[oparg], exc_st -- values[oparg])) {
- PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st);
+ PyObject *exc = PyStackRef_AsPyObjectSteal(exc_st);
assert(oparg >= 0 && oparg <= 2);
if (oparg) {
}
else {
_PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int");
+ Py_DECREF(exc);
ERROR_NO_POP();
}
}
assert(exc && PyExceptionInstance_Check(exc));
- Py_INCREF(exc);
_PyErr_SetRaisedException(tstate, exc);
monitor_reraise(tstate, frame, this_instr);
goto exception_unwind;
PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st);
assert(exc && PyExceptionInstance_Check(exc));
- if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) {
+ int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration);
+ if (matches) {
DECREF_INPUTS();
}
else {
int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration);
if (matches) {
+ none = PyStackRef_None;
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
DECREF_INPUTS();
- none = PyStackRef_None;
}
else {
_PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
inst(LOAD_COMMON_CONSTANT, ( -- value)) {
// Keep in sync with _common_constants in opcode.py
- switch(oparg) {
- case CONSTANT_ASSERTIONERROR:
- value = PyStackRef_FromPyObjectImmortal(PyExc_AssertionError);
- break;
- case CONSTANT_NOTIMPLEMENTEDERROR:
- value = PyStackRef_FromPyObjectImmortal(PyExc_NotImplementedError);
- break;
- default:
- Py_FatalError("bad LOAD_COMMON_CONSTANT oparg");
+ // If we ever have more than two constants, use a lookup table
+ PyObject *val;
+ if (oparg == CONSTANT_ASSERTIONERROR) {
+ val = PyExc_AssertionError;
+ }
+ else {
+ assert(oparg == CONSTANT_NOTIMPLEMENTEDERROR);
+ val = PyExc_NotImplementedError;
}
+ value = PyStackRef_FromPyObjectImmortal(val);
}
inst(LOAD_BUILD_CLASS, ( -- bc)) {
PyObject *bc_o;
- ERROR_IF(PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o) < 0, error);
+ int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o);
+ ERROR_IF(err < 0, error);
if (bc_o == NULL) {
_PyErr_SetString(tstate, PyExc_NameError,
"__build_class__ not found");
DECREF_INPUTS();
ERROR_IF(true, error);
}
- if (PyDict_CheckExact(ns))
+ if (PyDict_CheckExact(ns)) {
err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- else
+ }
+ else {
err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
+ }
DECREF_INPUTS();
ERROR_IF(err, error);
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
PyObject *v_o;
int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o);
- if (err < 0) {
- ERROR_NO_POP();
- }
+ DECREF_INPUTS();
+ ERROR_IF(err < 0, error);
if (v_o == NULL) {
if (PyDict_CheckExact(GLOBALS())
&& PyDict_CheckExact(BUILTINS()))
else {
/* Slow-path if globals or builtins is not a dict */
/* namespace 1: globals */
- ERROR_IF(PyMapping_GetOptionalItem(GLOBALS(), name, &v_o) < 0, error);
+ int err = PyMapping_GetOptionalItem(GLOBALS(), name, &v_o);
+ ERROR_IF(err < 0, error);
if (v_o == NULL) {
/* namespace 2: builtins */
- ERROR_IF(PyMapping_GetOptionalItem(BUILTINS(), name, &v_o) < 0, error);
+ int err = PyMapping_GetOptionalItem(BUILTINS(), name, &v_o);
+ ERROR_IF(err < 0, error);
if (v_o == NULL) {
_PyEval_FormatExcCheckArg(
tstate, PyExc_NameError,
}
}
}
- DECREF_INPUTS();
v = PyStackRef_FromPyObjectSteal(v_o);
}
inst(BUILD_TUPLE, (values[oparg] -- tup)) {
PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg);
+ INPUTS_DEAD();
ERROR_IF(tup_o == NULL, error);
tup = PyStackRef_FromPyObjectSteal(tup_o);
}
inst(BUILD_LIST, (values[oparg] -- list)) {
PyObject *list_o = _PyList_FromStackRefSteal(values, oparg);
+ INPUTS_DEAD();
ERROR_IF(list_o == NULL, error);
list = PyStackRef_FromPyObjectSteal(list_o);
}
}
PyStackRef_CLOSE(values[i]);
}
+ DEAD(values);
if (err != 0) {
Py_DECREF(set_o);
ERROR_IF(true, error);
}
inst(SETUP_ANNOTATIONS, (--)) {
- int err;
PyObject *ann_dict;
if (LOCALS() == NULL) {
_PyErr_Format(tstate, PyExc_SystemError,
ERROR_IF(true, error);
}
/* check if __annotations__ in locals()... */
- ERROR_IF(PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict) < 0, error);
+ int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict);
+ ERROR_IF(err < 0, error);
if (ann_dict == NULL) {
ann_dict = PyDict_New();
ERROR_IF(ann_dict == NULL, error);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, global_super, arg);
- ERROR_IF(err, error);
+ if (err) {
+ DECREF_INPUTS();
+ ERROR_IF(true, error);
+ }
}
// we make no attempt to optimize here; specializations should
// handle any case whose performance we care about
}
if (method_found) {
self_or_null = self_st; // transfer ownership
+ DEAD(self_st);
} else {
PyStackRef_CLOSE(self_st);
self_or_null = PyStackRef_NULL;
*/
assert(attr_o != NULL); // No errors on this branch
self_or_null = owner; // Transfer ownership
+ DEAD(owner);
}
else {
/* meth is not an unbound method (but a regular attr, or
attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
DECREF_INPUTS();
ERROR_IF(attr_o == NULL, error);
+ /* We need to define self_or_null on all paths */
+ self_or_null = PyStackRef_NULL;
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
}
STAT_INC(LOAD_ATTR, hit);
new_frame = _PyFrame_PushUnchecked(tstate, PyStackRef_FromPyObjectNew(fget), 1, frame);
new_frame->localsplus[0] = owner;
+ DEAD(owner);
}
macro(LOAD_ATTR_PROPERTY) =
// Manipulate stack directly because we exit with DISPATCH_INLINED().
STACK_SHRINK(1);
new_frame->localsplus[0] = owner;
+ DEAD(owner);
new_frame->localsplus[1] = PyStackRef_FromPyObjectNew(name);
frame->return_offset = (uint16_t)(next_instr - this_instr);
DISPATCH_INLINED(new_frame);
// 1 if NaN, 2 if <, 4 if >, 8 if ==; this matches low four bits of the oparg
int sign_ish = COMPARISON_BIT(dleft, dright);
_Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc);
+ DEAD(left);
_Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc);
+ DEAD(right);
res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False;
// It's always a bool, so we don't care about oparg & 16.
}
// 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg
int sign_ish = COMPARISON_BIT(ileft, iright);
_Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);
+ DEAD(left);
_Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);
+ DEAD(right);
res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False;
// It's always a bool, so we don't care about oparg & 16.
}
int eq = _PyUnicode_Equal(left_o, right_o);
assert((oparg >> 5) == Py_EQ || (oparg >> 5) == Py_NE);
_Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc);
+ DEAD(left);
_Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);
+ DEAD(right);
assert(eq == 0 || eq == 1);
assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS);
assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS);
replaced op(_POP_JUMP_IF_FALSE, (cond -- )) {
assert(PyStackRef_BoolCheck(cond));
int flag = PyStackRef_Is(cond, PyStackRef_False);
+ DEAD(cond);
#if ENABLE_SPECIALIZATION
this_instr[1].cache = (this_instr[1].cache << 1) | flag;
#endif
replaced op(_POP_JUMP_IF_TRUE, (cond -- )) {
assert(PyStackRef_BoolCheck(cond));
int flag = PyStackRef_Is(cond, PyStackRef_True);
+ DEAD(cond);
#if ENABLE_SPECIALIZATION
this_instr[1].cache = (this_instr[1].cache << 1) | flag;
#endif
op(_IS_NONE, (value -- b)) {
if (PyStackRef_Is(value, PyStackRef_None)) {
b = PyStackRef_True;
+ DEAD(value);
}
else {
b = PyStackRef_False;
ERROR_NO_POP();
}
iter = iterable;
+ DEAD(iterable);
}
else if (PyGen_CheckExact(iterable_o)) {
iter = iterable;
+ DEAD(iterable);
}
else {
/* `iterable` is not a generator. */
iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o));
+ DEAD(iterable);
if (PyStackRef_IsNull(iter)) {
ERROR_NO_POP();
}
PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o);
if (next_o == NULL) {
- next = PyStackRef_NULL;
if (_PyErr_Occurred(tstate)) {
int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration);
if (!matches) {
NOP,
};
- inst(PUSH_EXC_INFO, (new_exc -- prev_exc, new_exc)) {
+ inst(PUSH_EXC_INFO, (exc -- prev_exc, new_exc)) {
_PyErr_StackItem *exc_info = tstate->exc_info;
if (exc_info->exc_value != NULL) {
else {
prev_exc = PyStackRef_None;
}
- assert(PyStackRef_ExceptionInstanceCheck(new_exc));
- exc_info->exc_value = PyStackRef_AsPyObjectNew(new_exc);
+ assert(PyStackRef_ExceptionInstanceCheck(exc));
+ exc_info->exc_value = PyStackRef_AsPyObjectNew(exc);
+ new_exc = exc;
+ DEAD(exc);
}
op(_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, (owner -- owner)) {
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
self = owner;
+ DEAD(owner);
}
macro(LOAD_ATTR_METHOD_WITH_VALUES) =
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
self = owner;
+ DEAD(owner);
}
macro(LOAD_ATTR_METHOD_NO_DICT) =
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
self = owner;
+ DEAD(owner);
}
macro(LOAD_ATTR_METHOD_LAZY_DICT) =
CALL_NON_PY_GENERAL,
};
- specializing op(_SPECIALIZE_CALL, (counter/1, callable, self_or_null[1], args[oparg] -- callable, self_or_null[1], args[oparg])) {
+ specializing op(_SPECIALIZE_CALL, (counter/1, callable[1], self_or_null[1], args[oparg] -- callable[1], self_or_null[1], args[oparg])) {
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
- _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0]));
+ _Py_Specialize_Call(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0]));
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL);
#endif /* ENABLE_SPECIALIZATION */
}
- op(_MAYBE_EXPAND_METHOD, (callable, self_or_null[1], args[oparg] -- func, maybe_self[1], args[oparg])) {
- if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_MAYBE_EXPAND_METHOD, (callable[1], self_or_null[1], args[oparg] -- func[1], maybe_self[1], args[oparg])) {
+ if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyObject *self = ((PyMethodObject *)callable_o)->im_self;
maybe_self[0] = PyStackRef_FromPyObjectNew(self);
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
- func = PyStackRef_FromPyObjectNew(method);
- PyStackRef_CLOSE(callable);
- }
- else {
- func = callable;
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(method);
+ PyStackRef_CLOSE(temp);
}
}
// When calling Python, inline the call using DISPATCH_INLINED().
- op(_DO_CALL, (callable, self_or_null[1], args[oparg] -- res)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_DO_CALL, (callable[1], self_or_null[1], args[oparg] -- res)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
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));
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, total_args, NULL, frame
);
// Manipulate stack directly since we leave using DISPATCH_INLINED().
- STACK_SHRINK(oparg + 2);
+ SYNC_SP();
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
if (new_frame == NULL) {
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ DEAD(self_or_null);
ERROR_IF(true, error);
}
PyObject *res_o = PyObject_Vectorcall(
}
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ DEAD(self_or_null);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
- op(_MONITOR_CALL, (func, maybe_self[1], args[oparg] -- func, maybe_self[1], args[oparg])) {
+ op(_MONITOR_CALL, (func[1], maybe_self[1], args[oparg] -- func[1], maybe_self[1], args[oparg])) {
int is_meth = !PyStackRef_IsNull(maybe_self[0]);
- PyObject *function = PyStackRef_AsPyObjectBorrow(func);
+ PyObject *function = PyStackRef_AsPyObjectBorrow(func[0]);
PyObject *arg0;
if (is_meth) {
arg0 = PyStackRef_AsPyObjectBorrow(maybe_self[0]);
else {
arg0 = &_PyInstrumentation_MISSING;
}
+ SYNC_SP();
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, function, arg0
macro(CALL) = _SPECIALIZE_CALL + unused/2 + _MAYBE_EXPAND_METHOD + _DO_CALL + _CHECK_PERIODIC;
macro(INSTRUMENTED_CALL) = unused/3 + _MAYBE_EXPAND_METHOD + _MONITOR_CALL + _DO_CALL + _CHECK_PERIODIC;
- op(_PY_FRAME_GENERAL, (callable, self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_PY_FRAME_GENERAL, (callable[1], self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
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));
- new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ _PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
+ tstate, callable[0], locals,
args, total_args, NULL, frame
);
- // The frame has stolen all the arguments from the stack,
- // so there is no need to clean them up.
+ // The frame has stolen all the arguments from the stack.
+ INPUTS_DEAD();
SYNC_SP();
- if (new_frame == NULL) {
+ if (temp == NULL) {
ERROR_NO_POP();
}
+ new_frame = temp;
}
- op(_CHECK_FUNCTION_VERSION, (func_version/2, callable, self_or_null[1], unused[oparg] -- callable, self_or_null[1], unused[oparg])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CHECK_FUNCTION_VERSION, (func_version/2, callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
EXIT_IF(!PyFunction_Check(callable_o));
PyFunctionObject *func = (PyFunctionObject *)callable_o;
EXIT_IF(func->func_version != func_version);
_SAVE_RETURN_OFFSET +
_PUSH_FRAME;
- op(_CHECK_METHOD_VERSION, (func_version/2, callable, null[1], unused[oparg] -- callable, null[1], unused[oparg])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CHECK_METHOD_VERSION, (func_version/2, callable[1], null[1], unused[oparg] -- callable[1], null[1], unused[oparg])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
EXIT_IF(Py_TYPE(callable_o) != &PyMethod_Type);
PyObject *func = ((PyMethodObject *)callable_o)->im_func;
EXIT_IF(!PyStackRef_IsNull(null[0]));
}
- op(_EXPAND_METHOD, (callable, null[1], unused[oparg] -- method, self[1], unused[oparg])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
-
+ op(_EXPAND_METHOD, (callable[1], null[1], unused[oparg] -- method[1], self[1], unused[oparg])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
assert(PyStackRef_IsNull(null[0]));
+ DEAD(null);
assert(Py_TYPE(callable_o) == &PyMethod_Type);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- assert(PyStackRef_FunctionCheck(method));
- PyStackRef_CLOSE(callable);
+ _PyStackRef temp = callable[0];
+ method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(method[0]));
+ PyStackRef_CLOSE(temp);
}
macro(CALL_BOUND_METHOD_GENERAL) =
_SAVE_RETURN_OFFSET +
_PUSH_FRAME;
- op(_CHECK_IS_NOT_PY_CALLABLE, (callable, unused[1], unused[oparg] -- callable, unused[1], unused[oparg])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CHECK_IS_NOT_PY_CALLABLE, (callable[1], unused[1], unused[oparg] -- callable[1], unused[1], unused[oparg])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
EXIT_IF(PyFunction_Check(callable_o));
EXIT_IF(Py_TYPE(callable_o) == &PyMethod_Type);
}
- op(_CALL_NON_PY_GENERAL, (callable, self_or_null[1], args[oparg] -- res)) {
+ op(_CALL_NON_PY_GENERAL, (callable[1], self_or_null[1], args[oparg] -- res)) {
#if TIER_ONE
assert(opcode != INSTRUMENTED_CALL);
#endif
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
NULL);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ DEAD(self_or_null);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
_CALL_NON_PY_GENERAL +
_CHECK_PERIODIC;
- op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null[1], unused[oparg] -- callable, null[1], unused[oparg])) {
+ op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], null[1], unused[oparg] -- callable[1], null[1], unused[oparg])) {
EXIT_IF(!PyStackRef_IsNull(null[0]));
- EXIT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type);
+ EXIT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type);
}
- op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null[1], unused[oparg] -- func, self[1], unused[oparg])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], null[1], unused[oparg] -- func[1], self[1], unused[oparg])) {
+ DEAD(null);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
STAT_INC(CALL, hit);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- PyStackRef_CLOSE(callable);
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ PyStackRef_CLOSE(temp);
}
op(_CHECK_PEP_523, (--)) {
DEOPT_IF(tstate->interp->eval_frame);
}
- op(_CHECK_FUNCTION_EXACT_ARGS, (callable, self_or_null[1], unused[oparg] -- callable, self_or_null[1], unused[oparg])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CHECK_FUNCTION_EXACT_ARGS, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
assert(PyFunction_Check(callable_o));
PyFunctionObject *func = (PyFunctionObject *)callable_o;
PyCodeObject *code = (PyCodeObject *)func->func_code;
EXIT_IF(code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0])));
}
- op(_CHECK_STACK_SPACE, (callable, self_or_null[1], unused[oparg] -- callable, self_or_null[1], unused[oparg])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CHECK_STACK_SPACE, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyFunctionObject *func = (PyFunctionObject *)callable_o;
PyCodeObject *code = (PyCodeObject *)func->func_code;
DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize));
DEOPT_IF(tstate->py_recursion_remaining <= 1);
}
- replicate(5) pure op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) {
+ replicate(5) pure op(_INIT_CALL_PY_EXACT_ARGS, (callable[1], self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) {
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
first_non_self_local[i] = args[i];
}
+ INPUTS_DEAD();
}
op(_PUSH_FRAME, (new_frame: _PyInterpreterFrame* -- )) {
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
+ DEAD(new_frame);
SYNC_SP();
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
assert(oparg == 1);
DEOPT_IF(!PyStackRef_IsNull(null));
+ DEAD(null);
DEOPT_IF(callable_o != (PyObject *)&PyType_Type);
+ DEAD(callable);
STAT_INC(CALL, hit);
res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o)));
PyStackRef_CLOSE(arg);
DEOPT_IF(callable_o != (PyObject *)&PyUnicode_Type);
STAT_INC(CALL, hit);
res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o));
+ DEAD(null);
+ DEAD(callable);
PyStackRef_CLOSE(arg);
ERROR_IF(PyStackRef_IsNull(res), error);
}
DEOPT_IF(callable_o != (PyObject *)&PyTuple_Type);
STAT_INC(CALL, hit);
res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o));
+ DEAD(null);
+ DEAD(callable);
PyStackRef_CLOSE(arg);
ERROR_IF(PyStackRef_IsNull(res), error);
}
_CALL_TUPLE_1 +
_CHECK_PERIODIC;
- op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable, null, args[oparg] -- self, init, args[oparg])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
- DEOPT_IF(!PyStackRef_IsNull(null));
+ op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable[1], null[1], args[oparg] -- init[1], self[1], args[oparg])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
+ DEOPT_IF(!PyStackRef_IsNull(null[0]));
DEOPT_IF(!PyType_Check(callable_o));
PyTypeObject *tp = (PyTypeObject *)callable_o;
DEOPT_IF(tp->tp_version_tag != type_version);
PyCodeObject *code = (PyCodeObject *)init_func->func_code;
DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize));
STAT_INC(CALL, hit);
- self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp));
- if (PyStackRef_IsNull(self)) {
+ PyObject *self_o = _PyType_NewManagedObject(tp);
+ if (self_o == NULL) {
ERROR_NO_POP();
}
- PyStackRef_CLOSE(callable);
- init = PyStackRef_FromPyObjectNew(init_func);
+ self[0] = PyStackRef_FromPyObjectSteal(self_o);
+ _PyStackRef temp = callable[0];
+ init[0] = PyStackRef_FromPyObjectNew(init_func);
+ PyStackRef_CLOSE(temp);
}
- op(_CREATE_INIT_FRAME, (self, init, args[oparg] -- init_frame: _PyInterpreterFrame *)) {
+ op(_CREATE_INIT_FRAME, (init[1], self[1], args[oparg] -- init_frame: _PyInterpreterFrame *)) {
_PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked(
tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);
assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK);
/* Push self onto stack of shim */
- shim->localsplus[0] = PyStackRef_DUP(self);
- args[-1] = self;
+ shim->localsplus[0] = PyStackRef_DUP(self[0]);
+ DEAD(init);
+ DEAD(self);
init_frame = _PyEvalFramePushAndInit(
- tstate, init, NULL, args-1, oparg+1, NULL, shim);
+ tstate, init[0], NULL, args-1, oparg+1, NULL, shim);
SYNC_SP();
if (init_frame == NULL) {
_PyEval_FrameClearAndPop(tstate, shim);
Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name);
ERROR_NO_POP();
}
+ DEAD(should_be_none);
}
- op(_CALL_BUILTIN_CLASS, (callable, self_or_null[1], args[oparg] -- res)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CALL_BUILTIN_CLASS, (callable[1], self_or_null[1], args[oparg] -- res)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
total_args++;
}
+ DEAD(self_or_null);
DEOPT_IF(!PyType_Check(callable_o));
PyTypeObject *tp = (PyTypeObject *)callable_o;
DEOPT_IF(tp->tp_vectorcall == NULL);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
_CALL_BUILTIN_CLASS +
_CHECK_PERIODIC;
- op(_CALL_BUILTIN_O, (callable, self_or_null[1], args[oparg] -- res)) {
+ op(_CALL_BUILTIN_O, (callable[1], self_or_null[1], args[oparg] -- res)) {
/* Builtin METH_O functions */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(arg);
- PyStackRef_CLOSE(callable);
+ DEAD(args);
+ DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
_CALL_BUILTIN_O +
_CHECK_PERIODIC;
- op(_CALL_BUILTIN_FAST, (callable, self_or_null[1], args[oparg] -- res)) {
+ op(_CALL_BUILTIN_FAST, (callable[1], self_or_null[1], args[oparg] -- res)) {
/* Builtin METH_FASTCALL functions, without keywords */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
total_args++;
}
+ DEAD(self_or_null);
DEOPT_IF(!PyCFunction_CheckExact(callable_o));
DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL);
STAT_INC(CALL, hit);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
_CALL_BUILTIN_FAST +
_CHECK_PERIODIC;
- op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable, self_or_null[1], args[oparg] -- res)) {
+ op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable[1], self_or_null[1], args[oparg] -- res)) {
/* Builtin METH_FASTCALL | METH_KEYWORDS functions */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
_CALL_BUILTIN_FAST_WITH_KEYWORDS +
_CHECK_PERIODIC;
- inst(CALL_LEN, (unused/1, unused/2, callable, self_or_null[1], args[oparg] -- res)) {
+ inst(CALL_LEN, (unused/1, unused/2, callable[1], self_or_null[1], args[oparg] -- res)) {
/* len(o) */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
if (res_o == NULL) {
GOTO_ERROR(error);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(arg_stackref);
res = PyStackRef_FromPyObjectSteal(res_o);
}
- inst(CALL_ISINSTANCE, (unused/1, unused/2, callable, self_or_null[1], args[oparg] -- res)) {
+ inst(CALL_ISINSTANCE, (unused/1, unused/2, callable[1], self_or_null[1], args[oparg] -- res)) {
/* isinstance(o, o2) */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(inst_stackref);
PyStackRef_CLOSE(cls_stackref);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
}
// This is secretly a super-instruction
#endif
}
- op(_CALL_METHOD_DESCRIPTOR_O, (callable, self_or_null[1], args[oparg] -- res)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CALL_METHOD_DESCRIPTOR_O, (callable[1], self_or_null[1], args[oparg] -- res)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(self_stackref);
PyStackRef_CLOSE(arg_stackref);
- PyStackRef_CLOSE(callable);
+ DEAD(args);
+ DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
_CALL_METHOD_DESCRIPTOR_O +
_CHECK_PERIODIC;
- op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable, self_or_null[1], args[oparg] -- res)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable[1], self_or_null[1], args[oparg] -- res)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
EXIT_IF(!Py_IS_TYPE(self, d_type));
STAT_INC(CALL, hit);
int nargs = total_args - 1;
- PyCFunctionFastWithKeywords cfunc =
- (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
DECREF_INPUTS();
ERROR_IF(true, error);
}
+ PyCFunctionFastWithKeywords cfunc =
+ (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS +
_CHECK_PERIODIC;
- op(_CALL_METHOD_DESCRIPTOR_NOARGS, (callable, self_or_null[1], args[oparg] -- res)) {
+ op(_CALL_METHOD_DESCRIPTOR_NOARGS, (callable[1], self_or_null[1], args[oparg] -- res)) {
assert(oparg == 0 || oparg == 1);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(self_stackref);
- PyStackRef_CLOSE(callable);
+ DEAD(args);
+ DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
_CALL_METHOD_DESCRIPTOR_NOARGS +
_CHECK_PERIODIC;
- op(_CALL_METHOD_DESCRIPTOR_FAST, (callable, self_or_null[1], args[oparg] -- res)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CALL_METHOD_DESCRIPTOR_FAST, (callable[1], self_or_null[1], args[oparg] -- res)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]);
EXIT_IF(!Py_IS_TYPE(self, method->d_common.d_type));
STAT_INC(CALL, hit);
- PyCFunctionFast cfunc =
- (PyCFunctionFast)(void(*)(void))meth->ml_meth;
int nargs = total_args - 1;
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
DECREF_INPUTS();
ERROR_IF(true, error);
}
+ PyCFunctionFast cfunc =
+ (PyCFunctionFast)(void(*)(void))meth->ml_meth;
PyObject *res_o = cfunc(self, (args_o + 1), nargs);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
GO_TO_INSTRUCTION(CALL_KW);
}
- op(_DO_CALL_KW, (callable, self_or_null[1], args[oparg], kwnames -- res)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_MAYBE_EXPAND_METHOD_KW, (callable[1], self_or_null[1], args[oparg], kwnames_in -- func[1], maybe_self[1], args[oparg], kwnames_out)) {
+ if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
+ PyObject *self = ((PyMethodObject *)callable_o)->im_self;
+ maybe_self[0] = PyStackRef_FromPyObjectNew(self);
+ PyObject *method = ((PyMethodObject *)callable_o)->im_func;
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(method);
+ PyStackRef_CLOSE(temp);
+ }
+ kwnames_out = kwnames_in;
+ DEAD(kwnames_in);
+ }
+
+ op(_DO_CALL_KW, (callable[1], self_or_null[1], args[oparg], kwnames -- res)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);
// oparg counts all of the args, but *not* self:
args--;
total_args++;
}
- else if (Py_TYPE(callable_o) == &PyMethod_Type) {
- args--;
- total_args++;
- PyObject *self = ((PyMethodObject *)callable_o)->im_self;
- args[0] = PyStackRef_FromPyObjectNew(self);
- PyObject *method = ((PyMethodObject *)callable_o)->im_func;
- args[-1] = PyStackRef_FromPyObjectNew(method);
- PyStackRef_CLOSE(callable);
- callable_o = method;
- callable = args[-1];
- }
int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);
// Check if the call can be inlined or not
if (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));
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, positional_args, kwnames_o, frame
);
PyStackRef_CLOSE(kwnames);
- // Manipulate stack directly since we leave using DISPATCH_INLINED().
- STACK_SHRINK(oparg + 3);
+ // Sync stack explicitly since we leave using DISPATCH_INLINED().
+ SYNC_SP();
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
if (new_frame == NULL) {
}
PyStackRef_CLOSE(kwnames);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ DEAD(self_or_null);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
- op(_PY_FRAME_KW, (callable, self_or_null[1], args[oparg], kwnames -- new_frame: _PyInterpreterFrame*)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_PY_FRAME_KW, (callable[1], self_or_null[1], args[oparg], kwnames -- new_frame: _PyInterpreterFrame*)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
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));
new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, positional_args, kwnames_o, frame
);
PyStackRef_CLOSE(kwnames);
}
}
- op(_CHECK_FUNCTION_VERSION_KW, (func_version/2, callable, self_or_null[1], unused[oparg], kwnames -- callable, self_or_null[1], unused[oparg], kwnames)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CHECK_FUNCTION_VERSION_KW, (func_version/2, callable[1], self_or_null[1], unused[oparg], kwnames -- callable[1], self_or_null[1], unused[oparg], kwnames)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
EXIT_IF(!PyFunction_Check(callable_o));
PyFunctionObject *func = (PyFunctionObject *)callable_o;
EXIT_IF(func->func_version != func_version);
_SAVE_RETURN_OFFSET +
_PUSH_FRAME;
- op(_CHECK_METHOD_VERSION_KW, (func_version/2, callable, null[1], unused[oparg], kwnames -- callable, null[1], unused[oparg], kwnames)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CHECK_METHOD_VERSION_KW, (func_version/2, callable[1], null[1], unused[oparg], kwnames -- callable[1], null[1], unused[oparg], kwnames)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
EXIT_IF(Py_TYPE(callable_o) != &PyMethod_Type);
PyObject *func = ((PyMethodObject *)callable_o)->im_func;
EXIT_IF(!PyStackRef_IsNull(null[0]));
}
- op(_EXPAND_METHOD_KW, (callable, null[1], unused[oparg], kwnames -- method, self[1], unused[oparg], kwnames)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_EXPAND_METHOD_KW, (callable[1], null[1], unused[oparg], unused -- method[1], self[1], unused[oparg], unused)) {
+ _PyStackRef callable_s = callable[0];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s);
assert(PyStackRef_IsNull(null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- assert(PyStackRef_FunctionCheck(method));
- PyStackRef_CLOSE(callable);
+ method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(method[0]));
+ PyStackRef_CLOSE(callable_s);
}
macro(CALL_KW_BOUND_METHOD) =
_SAVE_RETURN_OFFSET +
_PUSH_FRAME;
- specializing op(_SPECIALIZE_CALL_KW, (counter/1, callable, self_or_null[1], args[oparg], kwnames -- callable, self_or_null[1], args[oparg], kwnames)) {
+ specializing op(_SPECIALIZE_CALL_KW, (counter/1, callable[1], self_or_null[1], args[oparg], kwnames -- callable[1], self_or_null[1], args[oparg], kwnames)) {
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
- _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0]));
+ _Py_Specialize_CallKw(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0]));
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL_KW);
macro(CALL_KW) =
_SPECIALIZE_CALL_KW +
unused/2 +
+ _MAYBE_EXPAND_METHOD_KW +
_DO_CALL_KW;
- op(_CHECK_IS_NOT_PY_CALLABLE_KW, (callable, unused[1], unused[oparg], kwnames -- callable, unused[1], unused[oparg], kwnames)) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ op(_CHECK_IS_NOT_PY_CALLABLE_KW, (callable[1], unused[1], unused[oparg], kwnames -- callable[1], unused[1], unused[oparg], kwnames)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
EXIT_IF(PyFunction_Check(callable_o));
EXIT_IF(Py_TYPE(callable_o) == &PyMethod_Type);
}
- op(_CALL_KW_NON_PY, (callable, self_or_null[1], args[oparg], kwnames -- res)) {
+ op(_CALL_KW_NON_PY, (callable[1], self_or_null[1], args[oparg], kwnames -- res)) {
#if TIER_ONE
assert(opcode != INSTRUMENTED_CALL);
#endif
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
PyStackRef_CLOSE(kwnames);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ DEAD(self_or_null);
+ PyStackRef_CLOSE(callable[0]);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
GO_TO_INSTRUCTION(CALL_FUNCTION_EX);
}
- inst(_DO_CALL_FUNCTION_EX, (func_st, unused, callargs_st, kwargs_st if (oparg & 1) -- result)) {
+ op(_MAKE_CALLARGS_A_TUPLE, (func, unused, callargs, kwargs_in if (oparg & 1) -- func, unused, tuple, kwargs_out if (oparg & 1))) {
+ PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
+ if (PyTuple_CheckExact(callargs_o)) {
+ tuple = callargs;
+ DEAD(callargs);
+ }
+ else {
+ int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
+ if (err < 0) {
+ ERROR_NO_POP();
+ }
+ PyObject *tuple_o = PySequence_Tuple(callargs_o);
+ if (tuple_o == NULL) {
+ ERROR_NO_POP();
+ }
+ PyStackRef_CLOSE(callargs);
+ tuple = PyStackRef_FromPyObjectSteal(tuple_o);
+ }
+ kwargs_out = kwargs_in;
+ DEAD(kwargs_in);
+ }
+
+ op(_DO_CALL_FUNCTION_EX, (func_st, unused, callargs_st, kwargs_st if (oparg & 1) -- result)) {
PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st);
PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st);
// DICT_MERGE is called before this opcode if there are kwargs.
// It converts all dict subtypes in kwargs into regular dicts.
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
- if (!PyTuple_CheckExact(callargs)) {
- int err = check_args_iterable(tstate, func, callargs);
- if (err < 0) {
- ERROR_NO_POP();
- }
- PyObject *tuple = PySequence_Tuple(callargs);
- if (tuple == NULL) {
- ERROR_NO_POP();
- }
- PyStackRef_CLOSE(callargs_st);
- callargs_st = PyStackRef_FromPyObjectSteal(tuple);
- callargs = tuple;
- }
assert(PyTuple_CheckExact(callargs));
EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func);
+ PyObject *result_o;
+ assert(!_PyErr_Occurred(tstate));
if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) {
PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ?
PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, func, arg);
- if (err) ERROR_NO_POP();
- result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs));
+ if (err) {
+ ERROR_NO_POP();
+ }
+ result_o = PyObject_Call(func, callargs, kwargs);
if (!PyFunction_Check(func) && !PyMethod_Check(func)) {
- if (PyStackRef_IsNull(result)) {
+ if (result_o == NULL) {
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, func, arg);
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, func, arg);
if (err < 0) {
- PyStackRef_CLEAR(result);
+ Py_CLEAR(result_o);
}
}
}
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- // Need to manually shrink the stack since we exit with DISPATCH_INLINED.
- STACK_SHRINK(oparg + 3);
+ // Need to sync the stack since we exit with DISPATCH_INLINED.
+ INPUTS_DEAD();
+ SYNC_SP();
if (new_frame == NULL) {
ERROR_NO_POP();
}
frame->return_offset = 1;
DISPATCH_INLINED(new_frame);
}
- result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs));
+ result_o = PyObject_Call(func, callargs, kwargs);
}
- DECREF_INPUTS();
- assert(PyStackRef_AsPyObjectBorrow(PEEK(2 + (oparg & 1))) == NULL);
- ERROR_IF(PyStackRef_IsNull(result), error);
+ PyStackRef_XCLOSE(kwargs_st);
+ DEAD(kwargs_st);
+ PyStackRef_CLOSE(callargs_st);
+ PyStackRef_CLOSE(func_st);
+ ERROR_IF(result_o == NULL, error);
+ result = PyStackRef_FromPyObjectSteal(result_o);
}
macro(CALL_FUNCTION_EX) =
+ _MAKE_CALLARGS_A_TUPLE +
_DO_CALL_FUNCTION_EX +
_CHECK_PERIODIC;
PyFunction_New(codeobj, GLOBALS());
PyStackRef_CLOSE(codeobj_st);
- if (func_obj == NULL) {
- ERROR_NO_POP();
- }
+ ERROR_IF(func_obj == NULL, error);
_PyFunction_SetVersion(
func_obj, ((PyCodeObject *)codeobj)->co_version);
func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);
}
- inst(SET_FUNCTION_ATTRIBUTE, (attr_st, func_st -- func_st)) {
- PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
- PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st);
-
+ inst(SET_FUNCTION_ATTRIBUTE, (attr_st, func_in -- func_out)) {
+ PyObject *func = PyStackRef_AsPyObjectBorrow(func_in);
+ PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st);
+ func_out = func_in;
+ DEAD(func_in);
assert(PyFunction_Check(func));
- PyFunctionObject *func_obj = (PyFunctionObject *)func;
- switch(oparg) {
- case MAKE_FUNCTION_CLOSURE:
- assert(func_obj->func_closure == NULL);
- func_obj->func_closure = attr;
- break;
- case MAKE_FUNCTION_ANNOTATIONS:
- assert(func_obj->func_annotations == NULL);
- func_obj->func_annotations = attr;
- break;
- case MAKE_FUNCTION_KWDEFAULTS:
- assert(PyDict_CheckExact(attr));
- assert(func_obj->func_kwdefaults == NULL);
- func_obj->func_kwdefaults = attr;
- break;
- case MAKE_FUNCTION_DEFAULTS:
- assert(PyTuple_CheckExact(attr));
- assert(func_obj->func_defaults == NULL);
- func_obj->func_defaults = attr;
- break;
- case MAKE_FUNCTION_ANNOTATE:
- assert(PyCallable_Check(attr));
- assert(func_obj->func_annotate == NULL);
- func_obj->func_annotate = attr;
- break;
- default:
- Py_UNREACHABLE();
- }
+ size_t offset = _Py_FunctionAttributeOffsets[oparg];
+ assert(offset != 0);
+ PyObject **ptr = (PyObject **)(((char *)func) + offset);
+ assert(*ptr == NULL);
+ *ptr = attr;
}
inst(RETURN_GENERATOR, (-- res)) {
assert(PyStackRef_FunctionCheck(frame->f_funcobj));
PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
- if (gen == NULL) {
- ERROR_NO_POP();
- }
+ ERROR_IF(gen == NULL, error);
assert(EMPTY());
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ SAVE_STACK();
_PyInterpreterFrame *gen_frame = &gen->gi_iframe;
frame->instr_ptr++;
_PyFrame_Copy(frame, gen_frame);
gen->gi_frame_state = FRAME_CREATED;
gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
_Py_LeaveRecursiveCallPy(tstate);
- res = PyStackRef_FromPyObjectSteal((PyObject *)gen);
_PyInterpreterFrame *prev = frame->previous;
_PyThreadState_PopFrame(tstate, frame);
frame = tstate->current_frame = prev;
LOAD_IP(frame->return_offset);
- LOAD_SP();
+ RELOAD_STACK();
+ res = PyStackRef_FromPyObjectSteal((PyObject *)gen);
LLTRACE_RESUME_FRAME();
}
}
else {
res = value;
+ DEAD(value);
}
}
macro(BINARY_OP) = _SPECIALIZE_BINARY_OP + _BINARY_OP;
- pure inst(SWAP, (bottom, unused[oparg-2], top --
- top, unused[oparg-2], bottom)) {
+ pure inst(SWAP, (bottom_in, unused[oparg-2], top_in --
+ top_out, unused[oparg-2], bottom_out)) {
+ bottom_out = bottom_in;
+ DEAD(bottom_in);
+ top_out = top_in;
+ DEAD(top_in);
assert(oparg >= 2);
}
original_opcode = code->_co_monitoring->lines[(int)(this_instr - _PyCode_CODE(code))].original_opcode;
next_instr = this_instr;
} else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
original_opcode = _Py_call_instrumentation_line(
tstate, frame, this_instr, prev_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
if (original_opcode < 0) {
next_instr = this_instr+1;
goto error;
///////// Tier-2 only opcodes /////////
op (_GUARD_IS_TRUE_POP, (flag -- )) {
+ int is_true = PyStackRef_Is(flag, PyStackRef_True);
+ DEAD(flag);
SYNC_SP();
- EXIT_IF(!PyStackRef_Is(flag, PyStackRef_True));
- assert(PyStackRef_Is(flag, PyStackRef_True));
+ EXIT_IF(!is_true);
}
op (_GUARD_IS_FALSE_POP, (flag -- )) {
+ int is_false = PyStackRef_Is(flag, PyStackRef_False);
+ DEAD(flag);
SYNC_SP();
- EXIT_IF(!PyStackRef_Is(flag, PyStackRef_False));
- assert(PyStackRef_Is(flag, PyStackRef_False));
+ EXIT_IF(!is_false);
}
op (_GUARD_IS_NONE_POP, (val -- )) {
- SYNC_SP();
- if (!PyStackRef_Is(val, PyStackRef_None)) {
+ int is_none = PyStackRef_Is(val, PyStackRef_None);
+ if (!is_none) {
PyStackRef_CLOSE(val);
+ SYNC_SP();
EXIT_IF(1);
}
+ DEAD(val);
}
op (_GUARD_IS_NOT_NONE_POP, (val -- )) {
- SYNC_SP();
- EXIT_IF(PyStackRef_Is(val, PyStackRef_None));
+ int is_none = PyStackRef_Is(val, PyStackRef_None);
PyStackRef_CLOSE(val);
+ SYNC_SP();
+ EXIT_IF(is_none);
}
op(_JUMP_TO_TOP, (--)) {
op(_INTERNAL_INCREMENT_OPT_COUNTER, (opt --)) {
_PyCounterOptimizerObject *exe = (_PyCounterOptimizerObject *)PyStackRef_AsPyObjectBorrow(opt);
exe->count++;
+ DEAD(opt);
}
tier2 op(_DYNAMIC_EXIT, (exit_p/4 --)) {
_PyInterpreterFrame *frame,
_Py_CODEUNIT *instr);
-static int check_args_iterable(PyThreadState *, PyObject *func, PyObject *vararg);
static int get_exception_handler(PyCodeObject *, int, int*, int*, int*);
static _PyInterpreterFrame *
_PyEvalFramePushAndInit_Ex(PyThreadState *tstate, _PyStackRef func,
}
};
+const size_t _Py_FunctionAttributeOffsets[] = {
+ [MAKE_FUNCTION_CLOSURE] = offsetof(PyFunctionObject, func_closure),
+ [MAKE_FUNCTION_ANNOTATIONS] = offsetof(PyFunctionObject, func_annotations),
+ [MAKE_FUNCTION_KWDEFAULTS] = offsetof(PyFunctionObject, func_kwdefaults),
+ [MAKE_FUNCTION_DEFAULTS] = offsetof(PyFunctionObject, func_defaults),
+ [MAKE_FUNCTION_ANNOTATE] = offsetof(PyFunctionObject, func_annotate),
+};
// PEP 634: Structural Pattern Matching
uopcode = next_uop->opcode;
#ifdef Py_DEBUG
if (lltrace >= 3) {
+ dump_stack(frame, stack_pointer);
if (next_uop->opcode == _START_EXECUTOR) {
printf("%4d uop: ", 0);
}
printf("%4d uop: ", (int)(next_uop - current_executor->trace));
}
_PyUOpPrint(next_uop);
- printf(" stack_level=%d\n",
- (int)(stack_pointer - _PyFrame_Stackbase(frame)));
+ printf("\n");
}
#endif
next_uop++;
return 0;
}
-static int
-check_args_iterable(PyThreadState *tstate, PyObject *func, PyObject *args)
+int
+_Py_Check_ArgsIterable(PyThreadState *tstate, PyObject *func, PyObject *args)
{
if (Py_TYPE(args)->tp_iter == NULL && !PySequence_Check(args)) {
- /* check_args_iterable() may be called with a live exception:
+ /* _Py_Check_ArgsIterable() may be called with a live exception:
* clear it to prevent calling _PyObject_FunctionStr() with an
* exception set. */
_PyErr_Clear(tstate);
/* Do interpreter dispatch accounting for tracing and instrumentation */
#define DISPATCH() \
{ \
+ assert(frame->stackpointer == NULL); \
NEXTOPARG(); \
PRE_DISPATCH_GOTO(); \
DISPATCH_GOTO(); \
case _CHECK_PERIODIC: {
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) JUMP_TO_ERROR();
}
break;
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate); \
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) JUMP_TO_ERROR();
}
}
oparg = CURRENT_OPARG();
_PyStackRef value_s = GETLOCAL(oparg);
if (PyStackRef_IsNull(value_s)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (1) JUMP_TO_ERROR();
}
value = PyStackRef_DUP(value_s);
case _END_SEND: {
_PyStackRef value;
_PyStackRef receiver;
+ _PyStackRef val;
value = stack_pointer[-1];
receiver = stack_pointer[-2];
(void)receiver;
+ val = value;
PyStackRef_CLOSE(receiver);
- stack_pointer[-2] = value;
+ stack_pointer[-2] = val;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
_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);
PyStackRef_CLOSE(value);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
_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);
PyStackRef_CLOSE(value);
if (err < 0) JUMP_TO_ERROR();
res = err ? PyStackRef_True : PyStackRef_False;
_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);
PyStackRef_CLOSE(value);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
STAT_INC(BINARY_OP, hit);
PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
_Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);
- _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);;
+ _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2] = res;
container = stack_pointer[-2];
PyObject *container_o = PyStackRef_AsPyObjectBorrow(container);
PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_GetItem(container_o, sub_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
if (res_o == NULL) JUMP_TO_ERROR();
stop = stack_pointer[-1];
start = stack_pointer[-2];
container = stack_pointer[-3];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start),
PyStackRef_AsPyObjectSteal(stop));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyObject *res_o;
// Can't use ERROR_IF() here, because we haven't
// DECREF'ed container yet, and we still own slice.
res_o = NULL;
}
else {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(slice);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
PyStackRef_CLOSE(container);
if (res_o == NULL) JUMP_TO_ERROR();
start = stack_pointer[-2];
container = stack_pointer[-3];
v = stack_pointer[-4];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start),
PyStackRef_AsPyObjectSteal(stop));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
int err;
if (slice == NULL) {
err = 1;
}
else {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(slice);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(container);
}
STAT_INC(BINARY_SUBSCR, hit);
PyObject *res_o;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int rc = PyDict_GetItemRef(dict, sub, &res_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (rc == 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetKeyError(sub);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(dict_st);
PyStackRef_CLOSE(sub_st);
PyHeapTypeObject *ht = (PyHeapTypeObject *)tp;
PyObject *getitem = ht->_spec_cache.getitem;
new_frame = _PyFrame_PushUnchecked(tstate, PyStackRef_FromPyObjectNew(getitem), 2, frame);
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
new_frame->localsplus[0] = container;
new_frame->localsplus[1] = sub;
frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
- stack_pointer[0].bits = (uintptr_t)new_frame;
- stack_pointer += 1;
+ stack_pointer[-2].bits = (uintptr_t)new_frame;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
}
oparg = CURRENT_OPARG();
v = stack_pointer[-1];
list = stack_pointer[-2 - (oparg-1)];
- if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
- PyStackRef_AsPyObjectSteal(v)) < 0) JUMP_TO_ERROR();
+ int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
+ PyStackRef_AsPyObjectSteal(v));
+ if (err < 0) JUMP_TO_ERROR();
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
oparg = CURRENT_OPARG();
v = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
if (err) JUMP_TO_ERROR();
stack_pointer += -1;
container = stack_pointer[-2];
v = stack_pointer[-3];
/* container[sub] = v */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(STORE_SUBSCR, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyDict_SetItem_Take2((PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(sub),
PyStackRef_AsPyObjectSteal(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(dict_st);
if (err) JUMP_TO_ERROR();
stack_pointer += -3;
sub = stack_pointer[-1];
container = stack_pointer[-2];
/* del container[sub] */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container),
PyStackRef_AsPyObjectBorrow(sub));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
if (err) JUMP_TO_ERROR();
oparg = CURRENT_OPARG();
value = stack_pointer[-1];
assert(oparg <= MAX_INTRINSIC_1);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
assert(oparg <= MAX_INTRINSIC_2);
PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st);
PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value2_st);
PyStackRef_CLOSE(value1_st);
if (res_o == NULL) JUMP_TO_ERROR();
#if TIER_ONE
assert(frame != &entry_frame);
#endif
+ _PyStackRef temp = retval;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *dying = frame;
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
LOAD_IP(frame->return_offset);
- res = retval;
+ res = temp;
LLTRACE_RESUME_FRAME();
stack_pointer[0] = res;
stack_pointer += 1;
getter = type->tp_as_async->am_aiter;
}
if (getter == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' requires an object with "
"__aiter__ method, got %.100s",
type->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(obj);
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
iter_o = (*getter)(obj_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(obj);
if (iter_o == NULL) JUMP_TO_ERROR();
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' received an object from __aiter__ "
"that does not implement __anext__: %.100s",
Py_TYPE(iter_o)->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(iter_o);
if (true) JUMP_TO_ERROR();
}
_PyStackRef aiter;
_PyStackRef awaitable;
aiter = stack_pointer[-1];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (awaitable_o == NULL) {
JUMP_TO_ERROR();
}
_PyStackRef iter;
oparg = CURRENT_OPARG();
iterable = stack_pointer[-1];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
if (iter_o == NULL) JUMP_TO_ERROR();
iter = PyStackRef_FromPyObjectSteal(iter_o);
assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1);
assert(oparg == 0 || oparg == 1);
gen->gi_frame_state = FRAME_SUSPENDED + oparg;
+ _PyStackRef temp = retval;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(INLINE_CACHE_ENTRIES_SEND == INLINE_CACHE_ENTRIES_FOR_ITER);
#if TIER_ONE
assert(frame->instr_ptr->op.code == INSTRUMENTED_LINE ||
- frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR);
+ frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR);
#endif
+ stack_pointer = _PyFrame_GetStackPointer(frame);
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
- LOAD_SP();
- value = retval;
+ value = temp;
LLTRACE_RESUME_FRAME();
stack_pointer[0] = value;
stack_pointer += 1;
_PyStackRef exc_value;
exc_value = stack_pointer[-1];
_PyErr_StackItem *exc_info = tstate->exc_info;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
Py_XSETREF(exc_info->exc_value,
PyStackRef_Is(exc_value, PyStackRef_None)
? NULL : PyStackRef_AsPyObjectSteal(exc_value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
_PyStackRef value;
oparg = CURRENT_OPARG();
// Keep in sync with _common_constants in opcode.py
- switch(oparg) {
- case CONSTANT_ASSERTIONERROR:
- value = PyStackRef_FromPyObjectImmortal(PyExc_AssertionError);
- break;
- case CONSTANT_NOTIMPLEMENTEDERROR:
- value = PyStackRef_FromPyObjectImmortal(PyExc_NotImplementedError);
- break;
- default:
- Py_FatalError("bad LOAD_COMMON_CONSTANT oparg");
+ // If we ever have more than two constants, use a lookup table
+ PyObject *val;
+ if (oparg == CONSTANT_ASSERTIONERROR) {
+ val = PyExc_AssertionError;
+ }
+ else {
+ assert(oparg == CONSTANT_NOTIMPLEMENTEDERROR);
+ val = PyExc_NotImplementedError;
}
+ value = PyStackRef_FromPyObjectImmortal(val);
stack_pointer[0] = value;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
case _LOAD_BUILD_CLASS: {
_PyStackRef bc;
PyObject *bc_o;
- if (PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o) < 0) JUMP_TO_ERROR();
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err < 0) JUMP_TO_ERROR();
if (bc_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetString(tstate, PyExc_NameError,
"__build_class__ not found");
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (true) JUMP_TO_ERROR();
}
bc = PyStackRef_FromPyObjectSteal(bc_o);
PyObject *ns = LOCALS();
int err;
if (ns == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when storing %R", name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
if (true) JUMP_TO_ERROR();
}
- if (PyDict_CheckExact(ns))
- err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- else
- err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
+ if (PyDict_CheckExact(ns)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ }
+ else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ }
PyStackRef_CLOSE(v);
if (err) JUMP_TO_ERROR();
stack_pointer += -1;
PyObject *ns = LOCALS();
int err;
if (ns == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals when deleting %R", name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_DelItem(ns, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// Can't use ERROR_IF here.
if (err != 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG,
name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
break;
seq = stack_pointer[-1];
output = &stack_pointer[-1];
_PyStackRef *top = output + oparg;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(seq);
if (res == 0) JUMP_TO_ERROR();
stack_pointer += -1 + oparg;
}
STAT_INC(UNPACK_SEQUENCE, hit);
val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0));
- stack_pointer[0] = val0;
val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1));
- stack_pointer[-1] = val1;
PyStackRef_CLOSE(seq);
+ stack_pointer[-1] = val1;
+ stack_pointer[0] = val0;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
seq = stack_pointer[-1];
right = &stack_pointer[(oparg & 0xFF)];
_PyStackRef *top = right + (oparg >> 8);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(seq);
if (res == 0) JUMP_TO_ERROR();
stack_pointer += (oparg & 0xFF) + (oparg >> 8);
owner = stack_pointer[-1];
v = stack_pointer[-2];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner),
name, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(owner);
if (err) JUMP_TO_ERROR();
oparg = CURRENT_OPARG();
owner = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
if (err) JUMP_TO_ERROR();
stack_pointer += -1;
oparg = CURRENT_OPARG();
v = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
if (err) JUMP_TO_ERROR();
stack_pointer += -1;
case _DELETE_GLOBAL: {
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);
// Can't use ERROR_IF here.
if (err < 0) {
JUMP_TO_ERROR();
}
if (err == 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
break;
_PyStackRef locals;
PyObject *l = LOCALS();
if (l == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetString(tstate, PyExc_SystemError,
"no locals found");
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (true) JUMP_TO_ERROR();
}
locals = PyStackRef_FromPyObjectNew(l);
_PyStackRef v;
oparg = CURRENT_OPARG();
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *v_o = _PyEval_LoadName(tstate, frame, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (v_o == NULL) JUMP_TO_ERROR();
v = PyStackRef_FromPyObjectSteal(v_o);
stack_pointer[0] = v;
oparg = CURRENT_OPARG();
res = &stack_pointer[0];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(*res)) JUMP_TO_ERROR();
null = PyStackRef_NULL;
if (oparg & 1) stack_pointer[1] = null;
oparg = CURRENT_OPARG();
_PyStackRef v = GETLOCAL(oparg);
if (PyStackRef_IsNull(v)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (1) JUMP_TO_ERROR();
}
SETLOCAL(oparg, PyStackRef_NULL);
// Fortunately we don't need its superpower.
PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL);
if (oldobj == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
Py_DECREF(oldobj);
assert(class_dict);
assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus);
name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(class_dict, name, &value_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
JUMP_TO_ERROR();
}
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
value_o = PyCell_GetRef(cell);
if (value_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
}
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
PyObject *value_o = PyCell_GetRef(cell);
if (value_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (true) JUMP_TO_ERROR();
}
value = PyStackRef_FromPyObjectSteal(value_o);
oparg = CURRENT_OPARG();
v = stack_pointer[-1];
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
list_st = stack_pointer[-2 - (oparg-1)];
PyObject *list = PyStackRef_AsPyObjectBorrow(list_st);
PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (none_val == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (matches &&
(Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
{
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Clear(tstate);
_PyErr_Format(tstate, PyExc_TypeError,
"Value after * must be an iterable, not %.200s",
Py_TYPE(iterable)->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(iterable_st);
if (true) JUMP_TO_ERROR();
oparg = CURRENT_OPARG();
iterable = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(iterable));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
if (err < 0) JUMP_TO_ERROR();
stack_pointer += -1;
_PyStackRef set;
oparg = CURRENT_OPARG();
values = &stack_pointer[-oparg];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *set_o = PySet_New(NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (set_o == NULL) {
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
int err = 0;
for (int i = 0; i < oparg; i++) {
if (err == 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
err = PySet_Add(set_o, PyStackRef_AsPyObjectBorrow(values[i]));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(values[i]);
}
}
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *map_o = _PyDict_FromItems(
values_o, 2,
values_o+1, 2,
oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(values_o);
for (int _i = oparg*2; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
}
case _SETUP_ANNOTATIONS: {
- int err;
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);
if (true) JUMP_TO_ERROR();
}
/* check if __annotations__ in locals()... */
- if (PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict) < 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) JUMP_TO_ERROR();
if (ann_dict == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
ann_dict = PyDict_New();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (ann_dict == NULL) JUMP_TO_ERROR();
+ _PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
ann_dict);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(ann_dict);
if (err) JUMP_TO_ERROR();
}
dict = stack_pointer[-2 - (oparg - 1)];
PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict);
PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyDict_Update(dict_o, update_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (matches) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
"'%.200s' object is not a mapping",
Py_TYPE(update_o)->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(update);
if (true) JUMP_TO_ERROR();
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict);
PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyDict_MergeEx(dict_o, update_o, 2);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatKwargsError(tstate, callable_o, update_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(update);
if (true) JUMP_TO_ERROR();
}
assert(PyDict_CheckExact(dict));
/* dict[key] = value */
// Do not DECREF INPUTS because the function steals the references
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyDict_SetItem_Take2(
(PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(key),
PyStackRef_AsPyObjectSteal(value)
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) JUMP_TO_ERROR();
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
}
STAT_INC(LOAD_SUPER_ATTR, hit);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(global_super_st);
PyStackRef_CLOSE(class_st);
PyStackRef_CLOSE(self_st);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
PyTypeObject *cls = (PyTypeObject *)class;
int method_found = 0;
+ _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);
PyStackRef_CLOSE(global_super_st);
PyStackRef_CLOSE(class_st);
if (attr_o == NULL) {
if (oparg & 1) {
/* Designed to work in tandem with CALL, pushes two values. */
attr_o = NULL;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (is_meth) {
/* We can bypass temporary bound method object.
meth is unbound method and obj is self.
}
else {
/* Classic, pushes one value. */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
if (attr_o == NULL) JUMP_TO_ERROR();
+ /* We need to define self_or_null on all paths */
+ self_or_null = PyStackRef_NULL;
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
stack_pointer[-1] = attr;
STAT_INC(LOAD_ATTR, hit);
null = PyStackRef_NULL;
attr = PyStackRef_FromPyObjectNew(attr_o);
- stack_pointer[-1] = attr;
PyStackRef_CLOSE(owner);
+ stack_pointer[-1] = attr;
break;
}
STAT_INC(LOAD_ATTR, hit);
null = PyStackRef_NULL;
attr = PyStackRef_FromPyObjectNew(attr_o);
- stack_pointer[-1] = attr;
PyStackRef_CLOSE(owner);
+ stack_pointer[-1] = attr;
stack_pointer[0] = null;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
null = PyStackRef_NULL;
PyStackRef_CLOSE(owner);
+ stack_pointer[-1] = attr;
break;
}
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
null = PyStackRef_NULL;
PyStackRef_CLOSE(owner);
+ stack_pointer[-1] = attr;
stack_pointer[0] = null;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
}
old_value = ep->me_value;
PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
ep->me_value = PyStackRef_AsPyObjectSteal(value);
// old_value should be DECREFed after GC track checking is done, if not, it could raise a segmentation fault,
// when dict only holds the strong reference to value in ep->me_value.
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert((oparg >> 5) <= Py_GE);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
if (res_o == NULL) JUMP_TO_ERROR();
if (oparg & 16) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res_bool = PyObject_IsTrue(res_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(res_o);
if (res_bool < 0) JUMP_TO_ERROR();
res = res_bool ? PyStackRef_True : PyStackRef_False;
}
else {
res = PyStackRef_FromPyObjectSteal(res_o);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
}
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = PySequence_Contains(right_o, left_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
if (res < 0) JUMP_TO_ERROR();
}
STAT_INC(CONTAINS_OP, hit);
// Note: both set and frozenset use the same seq_contains method!
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PySet_Contains((PySetObject *)right_o, left_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
if (res < 0) JUMP_TO_ERROR();
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CONTAINS_OP, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = PyDict_Contains(right_o, left_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
if (res < 0) JUMP_TO_ERROR();
exc_value_st = stack_pointer[-2];
PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st);
PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
PyStackRef_CLOSE(exc_value_st);
PyStackRef_CLOSE(match_type_st);
}
PyObject *match_o = NULL;
PyObject *rest_o = NULL;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PyEval_ExceptionGroupMatch(exc_value, match_type,
&match_o, &rest_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(exc_value_st);
PyStackRef_CLOSE(match_type_st);
if (res < 0) JUMP_TO_ERROR();
assert((match_o == NULL) == (rest_o == NULL));
if (match_o == NULL) JUMP_TO_ERROR();
if (!Py_IsNone(match_o)) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyErr_SetHandledException(match_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
rest = PyStackRef_FromPyObjectSteal(rest_o);
match = PyStackRef_FromPyObjectSteal(match_o);
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyExceptionInstance_Check(left_o));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyEval_CheckExceptTypeValid(tstate, right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
PyStackRef_CLOSE(right);
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = PyErr_GivenExceptionMatches(left_o, right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(right);
b = res ? PyStackRef_True : PyStackRef_False;
stack_pointer[-1] = b;
fromlist = stack_pointer[-1];
level = stack_pointer[-2];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_ImportName(tstate, frame, name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(level);
PyStackRef_CLOSE(fromlist);
if (res_o == NULL) JUMP_TO_ERROR();
oparg = CURRENT_OPARG();
from = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[0] = res;
_PyStackRef len;
obj = stack_pointer[-1];
// PUSH(len(TOS))
+ _PyFrame_SetStackPointer(frame, stack_pointer);
Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (len_i < 0) JUMP_TO_ERROR();
PyObject *len_o = PyLong_FromSsize_t(len_i);
if (len_o == NULL) JUMP_TO_ERROR();
// Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or
// None on failure.
assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names)));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attrs_o = _PyEval_MatchClass(tstate,
PyStackRef_AsPyObjectBorrow(subject),
PyStackRef_AsPyObjectBorrow(type), oparg,
PyStackRef_AsPyObjectBorrow(names));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(subject);
PyStackRef_CLOSE(type);
PyStackRef_CLOSE(names);
keys = stack_pointer[-1];
subject = stack_pointer[-2];
// On successful match, PUSH(values). Otherwise, PUSH(None).
+ _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) JUMP_TO_ERROR();
values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o);
stack_pointer[0] = values_or_none;
_PyStackRef iter;
iterable = stack_pointer[-1];
/* before: [obj]; after [getiter(obj)] */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable)));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
if (PyStackRef_IsNull(iter)) JUMP_TO_ERROR();
stack_pointer[-1] = iter;
if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
/* and it is used in a 'yield from' expression of a
regular generator. */
+ _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);
JUMP_TO_ERROR();
}
iter = iterable;
}
- else if (PyGen_CheckExact(iterable_o)) {
- iter = iterable;
- }
else {
- /* `iterable` is not a generator. */
- iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o));
- if (PyStackRef_IsNull(iter)) {
- JUMP_TO_ERROR();
+ if (PyGen_CheckExact(iterable_o)) {
+ iter = iterable;
+ }
+ else {
+ /* `iterable` is not a generator. */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (PyStackRef_IsNull(iter)) {
+ JUMP_TO_ERROR();
+ }
+ PyStackRef_CLOSE(iterable);
}
- PyStackRef_CLOSE(iterable);
}
stack_pointer[-1] = iter;
break;
iter = stack_pointer[-1];
/* before: [iter]; after: [iter, iter()] *or* [] (and jump over END_FOR.) */
PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (next_o == NULL) {
if (_PyErr_Occurred(tstate)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (!matches) {
JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_MonitorRaise(tstate, frame, frame->instr_ptr);
_PyErr_Clear(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
/* iterator ended normally */
/* The translator sets the deopt target just past the matching END_FOR */
PyObject *owner_o = PyStackRef_AsPyObjectSteal(owner);
PyObject *name = _Py_SpecialMethods[oparg].name;
PyObject *self_or_null_o;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(attr)) {
if (!_PyErr_Occurred(tstate)) {
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
_Py_SpecialMethods[oparg].error,
Py_TYPE(owner_o)->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
}
}
if (PyStackRef_IsNull(attr)) JUMP_TO_ERROR();
self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o);
- stack_pointer[-1] = attr;
- stack_pointer[0] = self_or_null;
- stack_pointer += 1;
+ stack_pointer[0] = attr;
+ stack_pointer[1] = self_or_null;
+ stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
break;
}
(void)lasti; // Shut up compiler warning if asserts are off
PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb};
int has_self = !PyStackRef_IsNull(exit_self);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,
(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(res)) JUMP_TO_ERROR();
stack_pointer[0] = res;
stack_pointer += 1;
}
case _PUSH_EXC_INFO: {
- _PyStackRef new_exc;
+ _PyStackRef exc;
_PyStackRef prev_exc;
- new_exc = stack_pointer[-1];
+ _PyStackRef new_exc;
+ exc = stack_pointer[-1];
_PyErr_StackItem *exc_info = tstate->exc_info;
if (exc_info->exc_value != NULL) {
prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value);
else {
prev_exc = PyStackRef_None;
}
- assert(PyStackRef_ExceptionInstanceCheck(new_exc));
- exc_info->exc_value = PyStackRef_AsPyObjectNew(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;
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
self = owner;
+ stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
self = owner;
+ stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
self = owner;
+ stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
case _MAYBE_EXPAND_METHOD: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
- _PyStackRef func;
+ _PyStackRef *callable;
+ _PyStackRef *func;
_PyStackRef *maybe_self;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ func = &stack_pointer[-2 - oparg];
maybe_self = &stack_pointer[-1 - oparg];
- if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyObject *self = ((PyMethodObject *)callable_o)->im_self;
maybe_self[0] = PyStackRef_FromPyObjectNew(self);
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
- func = PyStackRef_FromPyObjectNew(method);
- stack_pointer[-2 - oparg] = func;
- PyStackRef_CLOSE(callable);
- }
- else {
- func = callable;
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(method);
+ PyStackRef_CLOSE(temp);
}
break;
}
case _PY_FRAME_GENERAL: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyInterpreterFrame *new_frame;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
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));
- new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
+ tstate, callable[0], locals,
args, total_args, NULL, frame
);
- // The frame has stolen all the arguments from the stack,
- // so there is no need to clean them up.
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ // The frame has stolen all the arguments from the stack.
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
- if (new_frame == NULL) {
+ if (temp == NULL) {
JUMP_TO_ERROR();
}
+ new_frame = temp;
stack_pointer[0].bits = (uintptr_t)new_frame;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
}
case _CHECK_FUNCTION_VERSION: {
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
uint32_t func_version = (uint32_t)CURRENT_OPERAND();
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
if (!PyFunction_Check(callable_o)) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
case _CHECK_METHOD_VERSION: {
_PyStackRef *null;
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
uint32_t func_version = (uint32_t)CURRENT_OPERAND();
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
if (Py_TYPE(callable_o) != &PyMethod_Type) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
case _EXPAND_METHOD: {
_PyStackRef *null;
- _PyStackRef callable;
- _PyStackRef method;
+ _PyStackRef *callable;
+ _PyStackRef *method;
_PyStackRef *self;
oparg = CURRENT_OPARG();
null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ method = &stack_pointer[-2 - oparg];
self = &stack_pointer[-1 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
assert(PyStackRef_IsNull(null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- stack_pointer[-2 - oparg] = method;
- assert(PyStackRef_FunctionCheck(method));
- PyStackRef_CLOSE(callable);
+ _PyStackRef temp = callable[0];
+ method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(method[0]));
+ PyStackRef_CLOSE(temp);
break;
}
case _CHECK_IS_NOT_PY_CALLABLE: {
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
- callable = stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
if (PyFunction_Check(callable_o)) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
case _CALL_NON_PY_GENERAL: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
#if TIER_ONE
assert(opcode != INSTRUMENTED_CALL);
#endif
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
callable_o, args_o,
total_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: {
_PyStackRef *null;
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
if (!PyStackRef_IsNull(null[0])) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
- if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type) {
+ if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
}
case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: {
- _PyStackRef callable;
- _PyStackRef func;
+ _PyStackRef *null;
+ _PyStackRef *callable;
+ _PyStackRef *func;
_PyStackRef *self;
oparg = CURRENT_OPARG();
- callable = stack_pointer[-2 - oparg];
+ null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ func = &stack_pointer[-2 - oparg];
self = &stack_pointer[-1 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
STAT_INC(CALL, hit);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- stack_pointer[-2 - oparg] = func;
- PyStackRef_CLOSE(callable);
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ PyStackRef_CLOSE(temp);
break;
}
case _CHECK_FUNCTION_EXACT_ARGS: {
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
assert(PyFunction_Check(callable_o));
PyFunctionObject *func = (PyFunctionObject *)callable_o;
PyCodeObject *code = (PyCodeObject *)func->func_code;
}
case _CHECK_STACK_SPACE: {
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
- callable = stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyFunctionObject *func = (PyFunctionObject *)callable_o;
PyCodeObject *code = (PyCodeObject *)func->func_code;
if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) {
case _INIT_CALL_PY_EXACT_ARGS_0: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyInterpreterFrame *new_frame;
oparg = 0;
assert(oparg == CURRENT_OPARG());
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
case _INIT_CALL_PY_EXACT_ARGS_1: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyInterpreterFrame *new_frame;
oparg = 1;
assert(oparg == CURRENT_OPARG());
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
case _INIT_CALL_PY_EXACT_ARGS_2: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyInterpreterFrame *new_frame;
oparg = 2;
assert(oparg == CURRENT_OPARG());
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
case _INIT_CALL_PY_EXACT_ARGS_3: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyInterpreterFrame *new_frame;
oparg = 3;
assert(oparg == CURRENT_OPARG());
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
case _INIT_CALL_PY_EXACT_ARGS_4: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyInterpreterFrame *new_frame;
oparg = 4;
assert(oparg == CURRENT_OPARG());
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
case _INIT_CALL_PY_EXACT_ARGS: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyInterpreterFrame *new_frame;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(arg);
if (PyStackRef_IsNull(res)) JUMP_TO_ERROR();
stack_pointer[-3] = res;
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(arg);
if (PyStackRef_IsNull(res)) JUMP_TO_ERROR();
stack_pointer[-3] = res;
case _CHECK_AND_ALLOCATE_OBJECT: {
_PyStackRef *args;
- _PyStackRef null;
- _PyStackRef callable;
- _PyStackRef self;
- _PyStackRef init;
+ _PyStackRef *null;
+ _PyStackRef *callable;
+ _PyStackRef *init;
+ _PyStackRef *self;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
- null = stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ init = &stack_pointer[-2 - oparg];
+ self = &stack_pointer[-1 - oparg];
uint32_t type_version = (uint32_t)CURRENT_OPERAND();
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
- if (!PyStackRef_IsNull(null)) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
+ if (!PyStackRef_IsNull(null[0])) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
- self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp));
- if (PyStackRef_IsNull(self)) {
+ PyObject *self_o = _PyType_NewManagedObject(tp);
+ if (self_o == NULL) {
JUMP_TO_ERROR();
}
- PyStackRef_CLOSE(callable);
- init = PyStackRef_FromPyObjectNew(init_func);
- stack_pointer[-1 - oparg] = init;
- stack_pointer[-2 - oparg] = self;
+ self[0] = PyStackRef_FromPyObjectSteal(self_o);
+ _PyStackRef temp = callable[0];
+ init[0] = PyStackRef_FromPyObjectNew(init_func);
+ PyStackRef_CLOSE(temp);
break;
}
case _CREATE_INIT_FRAME: {
_PyStackRef *args;
- _PyStackRef init;
- _PyStackRef self;
+ _PyStackRef *self;
+ _PyStackRef *init;
_PyInterpreterFrame *init_frame;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
- init = stack_pointer[-1 - oparg];
- self = stack_pointer[-2 - oparg];
+ self = &stack_pointer[-1 - oparg];
+ init = &stack_pointer[-2 - oparg];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked(
tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK);
/* Push self onto stack of shim */
- shim->localsplus[0] = PyStackRef_DUP(self);
- args[-1] = self;
+ shim->localsplus[0] = PyStackRef_DUP(self[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
init_frame = _PyEvalFramePushAndInit(
- tstate, init, NULL, args-1, oparg+1, NULL, shim);
- stack_pointer += -2 - oparg;
+ tstate, init[0], NULL, args-1, oparg+1, NULL, shim);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-2 - oparg].bits = (uintptr_t)init_frame;
+ stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (init_frame == NULL) {
_PyEval_FrameClearAndPop(tstate, shim);
* We don't check recursion depth here,
* as it will be checked after start_frame */
tstate->py_recursion_remaining--;
- stack_pointer[0].bits = (uintptr_t)init_frame;
- stack_pointer += 1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
should_be_none = stack_pointer[-1];
assert(STACK_LEVEL() == 2);
if (!PyStackRef_Is(should_be_none, PyStackRef_None)) {
+ _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);
JUMP_TO_ERROR();
}
stack_pointer += -1;
case _CALL_BUILTIN_CLASS: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
case _CALL_BUILTIN_O: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* Builtin METH_O functions */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
_PyStackRef arg = args[0];
_Py_EnterRecursiveCallTstateUnchecked(tstate);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(arg);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
case _CALL_BUILTIN_FAST: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* Builtin METH_FASTCALL functions, without keywords */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
/* res = func(self, args, nargs) */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)(
PyCFunction_GET_SELF(callable_o),
args_o,
total_args);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
case _CALL_BUILTIN_FAST_WITH_KEYWORDS: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* Builtin METH_FASTCALL | METH_KEYWORDS functions */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
}
STAT_INC(CALL, hit);
/* res = func(self, args, nargs, kwnames) */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyCFunctionFastWithKeywords cfunc =
(PyCFunctionFastWithKeywords)(void(*)(void))
PyCFunction_GET_FUNCTION(callable_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
case _CALL_LEN: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* len(o) */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
_PyStackRef arg_stackref = args[0];
PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
Py_ssize_t len_i = PyObject_Length(arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (len_i < 0) {
JUMP_TO_ERROR();
}
if (res_o == NULL) {
GOTO_ERROR(error);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(arg_stackref);
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
case _CALL_ISINSTANCE: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* isinstance(o, o2) */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
_PyStackRef cls_stackref = args[1];
_PyStackRef inst_stackref = args[0];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (retval < 0) {
JUMP_TO_ERROR();
}
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(inst_stackref);
PyStackRef_CLOSE(cls_stackref);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
case _CALL_METHOD_DESCRIPTOR_O: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
_Py_EnterRecursiveCallTstateUnchecked(tstate);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc,
PyStackRef_AsPyObjectBorrow(self_stackref),
PyStackRef_AsPyObjectBorrow(arg_stackref));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(self_stackref);
PyStackRef_CLOSE(arg_stackref);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
}
STAT_INC(CALL, hit);
int nargs = total_args - 1;
- PyCFunctionFastWithKeywords cfunc =
- (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyCFunctionFastWithKeywords cfunc =
+ (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
case _CALL_METHOD_DESCRIPTOR_NOARGS: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
assert(oparg == 0 || oparg == 1);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
_Py_EnterRecursiveCallTstateUnchecked(tstate);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(self_stackref);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
case _CALL_METHOD_DESCRIPTOR_FAST: {
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
JUMP_TO_JUMP_TARGET();
}
STAT_INC(CALL, hit);
- PyCFunctionFast cfunc =
- (PyCFunctionFast)(void(*)(void))meth->ml_meth;
int nargs = total_args - 1;
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
if (true) JUMP_TO_ERROR();
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyCFunctionFast cfunc =
+ (PyCFunctionFast)(void(*)(void))meth->ml_meth;
PyObject *res_o = cfunc(self, (args_o + 1), nargs);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Clear the stack of the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
/* _INSTRUMENTED_CALL_KW is not a viable micro-op for tier 2 because it is instrumented */
+ case _MAYBE_EXPAND_METHOD_KW: {
+ _PyStackRef kwnames_in;
+ _PyStackRef *args;
+ _PyStackRef *self_or_null;
+ _PyStackRef *callable;
+ _PyStackRef *func;
+ _PyStackRef *maybe_self;
+ _PyStackRef kwnames_out;
+ oparg = CURRENT_OPARG();
+ kwnames_in = stack_pointer[-1];
+ args = &stack_pointer[-1 - oparg];
+ self_or_null = &stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-3 - oparg];
+ func = &stack_pointer[-3 - oparg];
+ maybe_self = &stack_pointer[-2 - oparg];
+ if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
+ PyObject *self = ((PyMethodObject *)callable_o)->im_self;
+ maybe_self[0] = PyStackRef_FromPyObjectNew(self);
+ PyObject *method = ((PyMethodObject *)callable_o)->im_func;
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(method);
+ PyStackRef_CLOSE(temp);
+ }
+ kwnames_out = kwnames_in;
+ stack_pointer[-1] = kwnames_out;
+ break;
+ }
+
/* _DO_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
case _PY_FRAME_KW: {
_PyStackRef kwnames;
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyInterpreterFrame *new_frame;
oparg = CURRENT_OPARG();
kwnames = stack_pointer[-1];
args = &stack_pointer[-1 - oparg];
self_or_null = &stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-3 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
assert(Py_TYPE(callable_o) == &PyFunction_Type);
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, positional_args, kwnames_o, frame
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(kwnames);
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
- stack_pointer += -3 - oparg;
+ stack_pointer[-3 - oparg].bits = (uintptr_t)new_frame;
+ stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (new_frame == NULL) {
JUMP_TO_ERROR();
}
- stack_pointer[0].bits = (uintptr_t)new_frame;
- stack_pointer += 1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
case _CHECK_FUNCTION_VERSION_KW: {
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
- callable = stack_pointer[-3 - oparg];
+ callable = &stack_pointer[-3 - oparg];
uint32_t func_version = (uint32_t)CURRENT_OPERAND();
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
if (!PyFunction_Check(callable_o)) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
case _CHECK_METHOD_VERSION_KW: {
_PyStackRef *null;
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
null = &stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - oparg];
+ callable = &stack_pointer[-3 - oparg];
uint32_t func_version = (uint32_t)CURRENT_OPERAND();
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
if (Py_TYPE(callable_o) != &PyMethod_Type) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
case _EXPAND_METHOD_KW: {
- _PyStackRef kwnames;
_PyStackRef *null;
- _PyStackRef callable;
- _PyStackRef method;
+ _PyStackRef *callable;
+ _PyStackRef *method;
_PyStackRef *self;
oparg = CURRENT_OPARG();
- kwnames = stack_pointer[-1];
null = &stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - oparg];
+ callable = &stack_pointer[-3 - oparg];
+ method = &stack_pointer[-3 - oparg];
self = &stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ _PyStackRef callable_s = callable[0];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s);
assert(PyStackRef_IsNull(null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- stack_pointer[-3 - oparg] = method;
- assert(PyStackRef_FunctionCheck(method));
- PyStackRef_CLOSE(callable);
- stack_pointer[-1] = kwnames;
+ method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(method[0]));
+ PyStackRef_CLOSE(callable_s);
break;
}
case _CHECK_IS_NOT_PY_CALLABLE_KW: {
- _PyStackRef callable;
+ _PyStackRef *callable;
oparg = CURRENT_OPARG();
- callable = stack_pointer[-3 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-3 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
if (PyFunction_Check(callable_o)) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
_PyStackRef kwnames;
_PyStackRef *args;
_PyStackRef *self_or_null;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef res;
oparg = CURRENT_OPARG();
kwnames = stack_pointer[-1];
args = &stack_pointer[-1 - oparg];
self_or_null = &stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - oparg];
+ callable = &stack_pointer[-3 - oparg];
#if TIER_ONE
assert(opcode != INSTRUMENTED_CALL);
#endif
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);
int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
callable_o, args_o,
positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
kwnames_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(kwnames);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) JUMP_TO_ERROR();
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-3 - oparg] = res;
/* _INSTRUMENTED_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it is instrumented */
- /* __DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
+ case _MAKE_CALLARGS_A_TUPLE: {
+ _PyStackRef kwargs_in = PyStackRef_NULL;
+ _PyStackRef callargs;
+ _PyStackRef func;
+ _PyStackRef tuple;
+ _PyStackRef kwargs_out = PyStackRef_NULL;
+ oparg = CURRENT_OPARG();
+ if (oparg & 1) { kwargs_in = stack_pointer[-(oparg & 1)]; }
+ callargs = stack_pointer[-1 - (oparg & 1)];
+ func = stack_pointer[-3 - (oparg & 1)];
+ PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
+ if (PyTuple_CheckExact(callargs_o)) {
+ tuple = callargs;
+ }
+ else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err < 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) {
+ JUMP_TO_ERROR();
+ }
+ PyStackRef_CLOSE(callargs);
+ tuple = PyStackRef_FromPyObjectSteal(tuple_o);
+ }
+ kwargs_out = kwargs_in;
+ stack_pointer[-1 - (oparg & 1)] = tuple;
+ if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_out;
+ break;
+ }
+
+ /* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */
case _MAKE_FUNCTION: {
_PyStackRef codeobj_st;
_PyStackRef func;
codeobj_st = stack_pointer[-1];
PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyFunctionObject *func_obj = (PyFunctionObject *)
PyFunction_New(codeobj, GLOBALS());
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(codeobj_st);
- if (func_obj == NULL) {
- JUMP_TO_ERROR();
- }
+ if (func_obj == NULL) JUMP_TO_ERROR();
_PyFunction_SetVersion(
func_obj, ((PyCodeObject *)codeobj)->co_version);
func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);
}
case _SET_FUNCTION_ATTRIBUTE: {
- _PyStackRef func_st;
+ _PyStackRef func_in;
_PyStackRef attr_st;
+ _PyStackRef func_out;
oparg = CURRENT_OPARG();
- func_st = stack_pointer[-1];
+ func_in = stack_pointer[-1];
attr_st = stack_pointer[-2];
- PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
- PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st);
+ PyObject *func = PyStackRef_AsPyObjectBorrow(func_in);
+ PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st);
+ func_out = func_in;
assert(PyFunction_Check(func));
- PyFunctionObject *func_obj = (PyFunctionObject *)func;
- switch(oparg) {
- case MAKE_FUNCTION_CLOSURE:
- assert(func_obj->func_closure == NULL);
- func_obj->func_closure = attr;
- break;
- case MAKE_FUNCTION_ANNOTATIONS:
- assert(func_obj->func_annotations == NULL);
- func_obj->func_annotations = attr;
- break;
- case MAKE_FUNCTION_KWDEFAULTS:
- assert(PyDict_CheckExact(attr));
- assert(func_obj->func_kwdefaults == NULL);
- func_obj->func_kwdefaults = attr;
- break;
- case MAKE_FUNCTION_DEFAULTS:
- assert(PyTuple_CheckExact(attr));
- assert(func_obj->func_defaults == NULL);
- func_obj->func_defaults = attr;
- break;
- case MAKE_FUNCTION_ANNOTATE:
- assert(PyCallable_Check(attr));
- assert(func_obj->func_annotate == NULL);
- func_obj->func_annotate = attr;
- break;
- default:
- Py_UNREACHABLE();
- }
- stack_pointer[-2] = func_st;
+ size_t offset = _Py_FunctionAttributeOffsets[oparg];
+ assert(offset != 0);
+ PyObject **ptr = (PyObject **)(((char *)func) + offset);
+ assert(*ptr == NULL);
+ *ptr = attr;
+ stack_pointer[-2] = func_out;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
_PyStackRef res;
assert(PyStackRef_FunctionCheck(frame->f_funcobj));
PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
- if (gen == NULL) {
- JUMP_TO_ERROR();
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (gen == NULL) JUMP_TO_ERROR();
assert(EMPTY());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *gen_frame = &gen->gi_iframe;
gen->gi_frame_state = FRAME_CREATED;
gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
_Py_LeaveRecursiveCallPy(tstate);
- res = PyStackRef_FromPyObjectSteal((PyObject *)gen);
_PyInterpreterFrame *prev = frame->previous;
_PyThreadState_PopFrame(tstate, frame);
frame = tstate->current_frame = prev;
LOAD_IP(frame->return_offset);
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ res = PyStackRef_FromPyObjectSteal((PyObject *)gen);
LLTRACE_RESUME_FRAME();
stack_pointer[0] = res;
stack_pointer += 1;
conversion_func conv_fn;
assert(oparg >= FVC_STR && oparg <= FVC_ASCII);
conv_fn = _PyEval_ConversionFuncs[oparg];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
if (result_o == NULL) JUMP_TO_ERROR();
result = PyStackRef_FromPyObjectSteal(result_o);
/* If value is a unicode object, then we know the result
* of format(value) is value itself. */
if (!PyUnicode_CheckExact(value_o)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
if (PyStackRef_IsNull(res)) JUMP_TO_ERROR();
}
_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));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
PyStackRef_CLOSE(fmt_spec);
if (res_o == NULL) JUMP_TO_ERROR();
PyObject *lhs_o = PyStackRef_AsPyObjectBorrow(lhs);
PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs);
assert(_PyEval_BinaryOps[oparg]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(lhs);
PyStackRef_CLOSE(rhs);
if (res_o == NULL) JUMP_TO_ERROR();
}
case _SWAP: {
- _PyStackRef top;
- _PyStackRef bottom;
+ _PyStackRef top_in;
+ _PyStackRef bottom_in;
+ _PyStackRef top_out;
+ _PyStackRef bottom_out;
oparg = CURRENT_OPARG();
- top = stack_pointer[-1];
- bottom = stack_pointer[-2 - (oparg-2)];
+ top_in = stack_pointer[-1];
+ bottom_in = stack_pointer[-2 - (oparg-2)];
+ bottom_out = bottom_in;
+ top_out = top_in;
assert(oparg >= 2);
- stack_pointer[-2 - (oparg-2)] = top;
- stack_pointer[-1] = bottom;
+ stack_pointer[-2 - (oparg-2)] = top_out;
+ stack_pointer[-1] = bottom_out;
break;
}
case _GUARD_IS_TRUE_POP: {
_PyStackRef flag;
flag = stack_pointer[-1];
+ int is_true = PyStackRef_Is(flag, PyStackRef_True);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
- if (!PyStackRef_Is(flag, PyStackRef_True)) {
+ if (!is_true) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
- assert(PyStackRef_Is(flag, PyStackRef_True));
break;
}
case _GUARD_IS_FALSE_POP: {
_PyStackRef flag;
flag = stack_pointer[-1];
+ int is_false = PyStackRef_Is(flag, PyStackRef_False);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
- if (!PyStackRef_Is(flag, PyStackRef_False)) {
+ if (!is_false) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
- assert(PyStackRef_Is(flag, PyStackRef_False));
break;
}
case _GUARD_IS_NONE_POP: {
_PyStackRef val;
val = stack_pointer[-1];
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
- if (!PyStackRef_Is(val, PyStackRef_None)) {
+ int is_none = PyStackRef_Is(val, PyStackRef_None);
+ if (!is_none) {
PyStackRef_CLOSE(val);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
if (1) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
case _GUARD_IS_NOT_NONE_POP: {
_PyStackRef val;
val = stack_pointer[-1];
+ int is_none = PyStackRef_Is(val, PyStackRef_None);
+ PyStackRef_CLOSE(val);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
- if (PyStackRef_Is(val, PyStackRef_None)) {
+ if (is_none) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
- PyStackRef_CLOSE(val);
break;
}
#if defined(Py_DEBUG) && !defined(_Py_JIT)
OPT_HIST(trace_uop_execution_counter, trace_run_length_hist);
if (lltrace >= 2) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
printf("SIDE EXIT: [UOp ");
_PyUOpPrint(&next_uop[-1]);
printf(", exit %u, temp %d, target %d -> %s]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyCode_CODE(code)),
_PyOpcode_OpName[target->op.code]);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
#endif
if (exit->executor && !exit->executor->vm_data.valid) {
}
else {
int chain_depth = current_executor->vm_data.chain_depth + 1;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, chain_depth);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (optimized <= 0) {
exit->temperature = restart_backoff_counter(temperature);
if (optimized < 0) {
_PyStackRef null;
PyObject *ptr = (PyObject *)CURRENT_OPERAND();
value = PyStackRef_FromPyObjectNew(ptr);
- stack_pointer[0] = value;
null = PyStackRef_NULL;
+ stack_pointer[0] = value;
stack_pointer[1] = null;
stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
#if defined(Py_DEBUG) && !defined(_Py_JIT)
OPT_HIST(trace_uop_execution_counter, trace_run_length_hist);
if (lltrace >= 2) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
printf("DYNAMIC EXIT: [UOp ");
_PyUOpPrint(&next_uop[-1]);
printf(", exit %u, temp %d, target %d -> %s]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyCode_CODE(_PyFrame_GetCode(frame))),
_PyOpcode_OpName[target->op.code]);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
#endif
_PyExecutorObject *executor;
exit->temperature = advance_backoff_counter(exit->temperature);
GOTO_TIER_ONE(target);
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, 0);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (optimized <= 0) {
exit->temperature = restart_backoff_counter(exit->temperature);
if (optimized < 0) {
_PyStackRef rhs;
_PyStackRef res;
// _SPECIALIZE_BINARY_OP
- rhs = stack_pointer[-1];
- lhs = stack_pointer[-2];
{
+ rhs = stack_pointer[-1];
+ lhs = stack_pointer[-2];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, LOCALS_ARRAY);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(BINARY_OP);
PyObject *lhs_o = PyStackRef_AsPyObjectBorrow(lhs);
PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs);
assert(_PyEval_BinaryOps[oparg]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(lhs);
PyStackRef_CLOSE(rhs);
if (res_o == NULL) goto pop_2_error;
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_FLOAT
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP);
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_INT
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP);
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_UNICODE
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyUnicode_CheckExact(left_o), BINARY_OP);
_PyStackRef left;
_PyStackRef right;
// _GUARD_BOTH_UNICODE
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyUnicode_CheckExact(left_o), BINARY_OP);
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_FLOAT
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP);
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_INT
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP);
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_FLOAT
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP);
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_INT
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP);
STAT_INC(BINARY_OP, hit);
PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
_Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);
- _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);;
+ _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);
if (res_o == NULL) goto pop_2_error;
res = PyStackRef_FromPyObjectSteal(res_o);
}
#endif /* ENABLE_SPECIALIZATION */
}
// _BINARY_SLICE
- stop = stack_pointer[-1];
- start = stack_pointer[-2];
- container = stack_pointer[-3];
{
+ stop = stack_pointer[-1];
+ start = stack_pointer[-2];
+ container = stack_pointer[-3];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start),
PyStackRef_AsPyObjectSteal(stop));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyObject *res_o;
// Can't use ERROR_IF() here, because we haven't
// DECREF'ed container yet, and we still own slice.
res_o = NULL;
}
else {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(slice);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
PyStackRef_CLOSE(container);
if (res_o == NULL) goto pop_3_error;
_PyStackRef sub;
_PyStackRef res;
// _SPECIALIZE_BINARY_SUBSCR
- sub = stack_pointer[-1];
- container = stack_pointer[-2];
{
+ sub = stack_pointer[-1];
+ container = stack_pointer[-2];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
+ assert(frame->stackpointer == NULL);
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_BinarySubscr(container, sub, next_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(BINARY_SUBSCR);
{
PyObject *container_o = PyStackRef_AsPyObjectBorrow(container);
PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_GetItem(container_o, sub_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
if (res_o == NULL) goto pop_2_error;
DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR);
STAT_INC(BINARY_SUBSCR, hit);
PyObject *res_o;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int rc = PyDict_GetItemRef(dict, sub, &res_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (rc == 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetKeyError(sub);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(dict_st);
PyStackRef_CLOSE(sub_st);
DEOPT_IF(tstate->interp->eval_frame, BINARY_SUBSCR);
}
// _BINARY_SUBSCR_CHECK_FUNC
- container = stack_pointer[-2];
{
+ container = stack_pointer[-2];
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container));
DEOPT_IF(!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE), BINARY_SUBSCR);
PyHeapTypeObject *ht = (PyHeapTypeObject *)tp;
STAT_INC(BINARY_SUBSCR, hit);
}
// _BINARY_SUBSCR_INIT_CALL
- sub = stack_pointer[-1];
{
+ sub = stack_pointer[-1];
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container));
PyHeapTypeObject *ht = (PyHeapTypeObject *)tp;
PyObject *getitem = ht->_spec_cache.getitem;
new_frame = _PyFrame_PushUnchecked(tstate, PyStackRef_FromPyObjectNew(getitem), 2, frame);
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
new_frame->localsplus[0] = container;
new_frame->localsplus[1] = sub;
frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *map_o = _PyDict_FromItems(
values_o, 2,
values_o+1, 2,
oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(values_o);
for (int _i = oparg*2; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
_PyStackRef *values;
_PyStackRef set;
values = &stack_pointer[-oparg];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *set_o = PySet_New(NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (set_o == NULL) {
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
int err = 0;
for (int i = 0; i < oparg; i++) {
if (err == 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
err = PySet_Add(set_o, PyStackRef_AsPyObjectBorrow(values[i]));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(values[i]);
}
PREDICTED(CALL);
_Py_CODEUNIT *this_instr = next_instr - 4;
(void)this_instr;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
- _PyStackRef func;
+ _PyStackRef *func;
_PyStackRef *maybe_self;
_PyStackRef res;
// _SPECIALIZE_CALL
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
- _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0]));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _Py_Specialize_Call(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0]));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL);
}
/* Skip 2 cache entries */
// _MAYBE_EXPAND_METHOD
- args = &stack_pointer[-oparg];
{
+ args = &stack_pointer[-oparg];
+ func = &stack_pointer[-2 - oparg];
maybe_self = &stack_pointer[-1 - oparg];
- if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyObject *self = ((PyMethodObject *)callable_o)->im_self;
maybe_self[0] = PyStackRef_FromPyObjectNew(self);
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
- func = PyStackRef_FromPyObjectNew(method);
- stack_pointer[-2 - oparg] = func;
- PyStackRef_CLOSE(callable);
- }
- else {
- func = callable;
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(method);
+ PyStackRef_CLOSE(temp);
}
}
// _DO_CALL
- self_or_null = maybe_self;
- callable = func;
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
{
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, total_args, NULL, frame
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// Manipulate stack directly since we leave using DISPATCH_INLINED().
- STACK_SHRINK(oparg + 2);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
if (new_frame == NULL) {
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
callable_o, args_o,
total_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
if (opcode == INSTRUMENTED_CALL) {
PyObject *arg = total_args == 0 ?
&_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]);
if (res_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, callable_o, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, callable_o, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
Py_CLEAR(res_o);
}
}
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_ALLOC_AND_ENTER_INIT);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
- _PyStackRef null;
+ _PyStackRef *callable;
+ _PyStackRef *null;
_PyStackRef *args;
- _PyStackRef self;
- _PyStackRef init;
+ _PyStackRef *init;
+ _PyStackRef *self;
_PyInterpreterFrame *init_frame;
_PyInterpreterFrame *new_frame;
/* Skip 1 cache entry */
DEOPT_IF(tstate->interp->eval_frame, CALL);
}
// _CHECK_AND_ALLOCATE_OBJECT
- args = &stack_pointer[-oparg];
- null = stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ args = &stack_pointer[-oparg];
+ null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ init = &stack_pointer[-2 - oparg];
+ self = &stack_pointer[-1 - oparg];
uint32_t type_version = read_u32(&this_instr[2].cache);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
- DEOPT_IF(!PyStackRef_IsNull(null), CALL);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
+ DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL);
DEOPT_IF(!PyType_Check(callable_o), CALL);
PyTypeObject *tp = (PyTypeObject *)callable_o;
DEOPT_IF(tp->tp_version_tag != type_version, CALL);
PyCodeObject *code = (PyCodeObject *)init_func->func_code;
DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize), CALL);
STAT_INC(CALL, hit);
- self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp));
- if (PyStackRef_IsNull(self)) {
+ PyObject *self_o = _PyType_NewManagedObject(tp);
+ if (self_o == NULL) {
goto error;
}
- PyStackRef_CLOSE(callable);
- init = PyStackRef_FromPyObjectNew(init_func);
- stack_pointer[-1 - oparg] = init;
+ self[0] = PyStackRef_FromPyObjectSteal(self_o);
+ _PyStackRef temp = callable[0];
+ init[0] = PyStackRef_FromPyObjectNew(init_func);
+ PyStackRef_CLOSE(temp);
}
// _CREATE_INIT_FRAME
{
+ args = &stack_pointer[-oparg];
+ self = &stack_pointer[-1 - oparg];
+ init = &stack_pointer[-2 - oparg];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked(
tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK);
/* Push self onto stack of shim */
- shim->localsplus[0] = PyStackRef_DUP(self);
- args[-1] = self;
+ shim->localsplus[0] = PyStackRef_DUP(self[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
init_frame = _PyEvalFramePushAndInit(
- tstate, init, NULL, args-1, oparg+1, NULL, shim);
- stack_pointer += -2 - oparg;
+ tstate, init[0], NULL, args-1, oparg+1, NULL, shim);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-2 - oparg].bits = (uintptr_t)init_frame;
+ stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (init_frame == NULL) {
_PyEval_FrameClearAndPop(tstate, shim);
tstate->py_recursion_remaining--;
}
// _PUSH_FRAME
- new_frame = init_frame;
{
+ new_frame = init_frame;
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
next_instr += 4;
INSTRUCTION_STATS(CALL_BOUND_METHOD_EXACT_ARGS);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *null;
- _PyStackRef func;
+ _PyStackRef *func;
_PyStackRef *self;
_PyStackRef *self_or_null;
_PyStackRef *args;
DEOPT_IF(tstate->interp->eval_frame, CALL);
}
// _CHECK_CALL_BOUND_METHOD_EXACT_ARGS
- null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL);
- DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type, CALL);
+ DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type, CALL);
}
// _INIT_CALL_BOUND_METHOD_EXACT_ARGS
{
+ func = &stack_pointer[-2 - oparg];
self = &stack_pointer[-1 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
STAT_INC(CALL, hit);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- stack_pointer[-2 - oparg] = func;
- PyStackRef_CLOSE(callable);
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ PyStackRef_CLOSE(temp);
}
// flush
// _CHECK_FUNCTION_VERSION
- callable = stack_pointer[-2 - oparg];
{
+ callable = &stack_pointer[-2 - oparg];
uint32_t func_version = read_u32(&this_instr[2].cache);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(!PyFunction_Check(callable_o), CALL);
PyFunctionObject *func = (PyFunctionObject *)callable_o;
DEOPT_IF(func->func_version != func_version, CALL);
}
// _CHECK_FUNCTION_EXACT_ARGS
- self_or_null = &stack_pointer[-1 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ self_or_null = &stack_pointer[-1 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
assert(PyFunction_Check(callable_o));
PyFunctionObject *func = (PyFunctionObject *)callable_o;
PyCodeObject *code = (PyCodeObject *)func->func_code;
}
// _CHECK_STACK_SPACE
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyFunctionObject *func = (PyFunctionObject *)callable_o;
PyCodeObject *code = (PyCodeObject *)func->func_code;
DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL);
DEOPT_IF(tstate->py_recursion_remaining <= 1, CALL);
}
// _INIT_CALL_PY_EXACT_ARGS
- args = &stack_pointer[-oparg];
{
+ args = &stack_pointer[-oparg];
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
next_instr += 4;
INSTRUCTION_STATS(CALL_BOUND_METHOD_GENERAL);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *null;
- _PyStackRef method;
+ _PyStackRef *method;
_PyStackRef *self;
_PyStackRef *self_or_null;
_PyStackRef *args;
DEOPT_IF(tstate->interp->eval_frame, CALL);
}
// _CHECK_METHOD_VERSION
- null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
uint32_t func_version = read_u32(&this_instr[2].cache);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(Py_TYPE(callable_o) != &PyMethod_Type, CALL);
PyObject *func = ((PyMethodObject *)callable_o)->im_func;
DEOPT_IF(!PyFunction_Check(func), CALL);
}
// _EXPAND_METHOD
{
+ method = &stack_pointer[-2 - oparg];
self = &stack_pointer[-1 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
assert(PyStackRef_IsNull(null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- stack_pointer[-2 - oparg] = method;
- assert(PyStackRef_FunctionCheck(method));
- PyStackRef_CLOSE(callable);
+ _PyStackRef temp = callable[0];
+ method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(method[0]));
+ PyStackRef_CLOSE(temp);
}
// flush
// _PY_FRAME_GENERAL
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
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));
- new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
+ tstate, callable[0], locals,
args, total_args, NULL, frame
);
- // The frame has stolen all the arguments from the stack,
- // so there is no need to clean them up.
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ // The frame has stolen all the arguments from the stack.
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
- if (new_frame == NULL) {
+ if (temp == NULL) {
goto error;
}
+ new_frame = temp;
}
// _SAVE_RETURN_OFFSET
{
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
next_instr += 4;
INSTRUCTION_STATS(CALL_BUILTIN_CLASS);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_BUILTIN_CLASS
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_BUILTIN_FAST);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_BUILTIN_FAST
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* Builtin METH_FASTCALL functions, without keywords */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
/* res = func(self, args, nargs) */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)(
PyCFunction_GET_SELF(callable_o),
args_o,
total_args);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_BUILTIN_FAST_WITH_KEYWORDS);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_BUILTIN_FAST_WITH_KEYWORDS
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* Builtin METH_FASTCALL | METH_KEYWORDS functions */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != (METH_FASTCALL | METH_KEYWORDS), CALL);
STAT_INC(CALL, hit);
/* res = func(self, args, nargs, kwnames) */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyCFunctionFastWithKeywords cfunc =
(PyCFunctionFastWithKeywords)(void(*)(void))
PyCFunction_GET_FUNCTION(callable_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_BUILTIN_O);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_BUILTIN_O
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* Builtin METH_O functions */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
_PyStackRef arg = args[0];
_Py_EnterRecursiveCallTstateUnchecked(tstate);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(arg);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
PREDICTED(CALL_FUNCTION_EX);
_Py_CODEUNIT *this_instr = next_instr - 1;
(void)this_instr;
+ _PyStackRef func;
+ _PyStackRef callargs;
+ _PyStackRef kwargs_in = PyStackRef_NULL;
+ _PyStackRef tuple;
+ _PyStackRef kwargs_out = PyStackRef_NULL;
_PyStackRef func_st;
_PyStackRef callargs_st;
_PyStackRef kwargs_st = PyStackRef_NULL;
_PyStackRef result;
- // __DO_CALL_FUNCTION_EX
- if (oparg & 1) { kwargs_st = stack_pointer[-(oparg & 1)]; }
- callargs_st = stack_pointer[-1 - (oparg & 1)];
- func_st = stack_pointer[-3 - (oparg & 1)];
+ // _MAKE_CALLARGS_A_TUPLE
{
- PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
- PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st);
- PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st);
- // DICT_MERGE is called before this opcode if there are kwargs.
- // It converts all dict subtypes in kwargs into regular dicts.
- assert(kwargs == NULL || PyDict_CheckExact(kwargs));
- if (!PyTuple_CheckExact(callargs)) {
- int err = check_args_iterable(tstate, func, callargs);
+ if (oparg & 1) { kwargs_in = stack_pointer[-(oparg & 1)]; }
+ callargs = stack_pointer[-1 - (oparg & 1)];
+ func = stack_pointer[-3 - (oparg & 1)];
+ PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
+ if (PyTuple_CheckExact(callargs_o)) {
+ tuple = callargs;
+ }
+ else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
goto error;
}
- PyObject *tuple = PySequence_Tuple(callargs);
- if (tuple == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyObject *tuple_o = PySequence_Tuple(callargs_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (tuple_o == NULL) {
goto error;
}
- PyStackRef_CLOSE(callargs_st);
- callargs_st = PyStackRef_FromPyObjectSteal(tuple);
- callargs = tuple;
+ PyStackRef_CLOSE(callargs);
+ tuple = PyStackRef_FromPyObjectSteal(tuple_o);
}
+ kwargs_out = kwargs_in;
+ }
+ // _DO_CALL_FUNCTION_EX
+ {
+ kwargs_st = kwargs_out;
+ callargs_st = tuple;
+ func_st = func;
+ PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
+ PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st);
+ PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st);
+ // DICT_MERGE is called before this opcode if there are kwargs.
+ // It converts all dict subtypes in kwargs into regular dicts.
+ assert(kwargs == NULL || PyDict_CheckExact(kwargs));
assert(PyTuple_CheckExact(callargs));
EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func);
+ PyObject *result_o;
+ assert(!_PyErr_Occurred(tstate));
if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) {
PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ?
PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;
+ stack_pointer[-1 - (oparg & 1)] = callargs_st;
+ if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, func, arg);
- if (err) goto error;
- result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err) {
+ goto error;
+ }
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ result_o = PyObject_Call(func, callargs, kwargs);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (!PyFunction_Check(func) && !PyMethod_Check(func)) {
- if (PyStackRef_IsNull(result)) {
+ if (result_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, func, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, func, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- PyStackRef_CLEAR(result);
+ Py_CLEAR(result_o);
}
}
}
Py_ssize_t nargs = PyTuple_GET_SIZE(callargs);
int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func));
+ stack_pointer[-1 - (oparg & 1)] = callargs_st;
+ if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- // Need to manually shrink the stack since we exit with DISPATCH_INLINED.
- STACK_SHRINK(oparg + 3);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ // Need to sync the stack since we exit with DISPATCH_INLINED.
+ stack_pointer += -3 - (oparg & 1);
+ assert(WITHIN_STACK_BOUNDS());
if (new_frame == NULL) {
goto error;
}
frame->return_offset = 1;
DISPATCH_INLINED(new_frame);
}
- result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs));
+ stack_pointer[-1 - (oparg & 1)] = callargs_st;
+ if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ result_o = PyObject_Call(func, callargs, kwargs);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
- PyStackRef_CLOSE(func_st);
- PyStackRef_CLOSE(callargs_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_XCLOSE(kwargs_st);
- assert(PyStackRef_AsPyObjectBorrow(PEEK(2 + (oparg & 1))) == NULL);
- if (PyStackRef_IsNull(result)) {
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ PyStackRef_CLOSE(callargs_st);
+ PyStackRef_CLOSE(func_st);
+ if (result_o == NULL) {
stack_pointer += -3 - (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
goto error;
}
+ result = PyStackRef_FromPyObjectSteal(result_o);
}
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-3 - (oparg & 1)] = result;
+ stack_pointer += -2 - (oparg & 1);
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-3 - (oparg & 1)] = result;
- stack_pointer += -2 - (oparg & 1);
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 2 + (oparg & 1);
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-3 - (oparg & 1)] = result;
_PyStackRef res;
value = stack_pointer[-1];
assert(oparg <= MAX_INTRINSIC_1);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
if (res_o == NULL) goto pop_1_error;
res = PyStackRef_FromPyObjectSteal(res_o);
assert(oparg <= MAX_INTRINSIC_2);
PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st);
PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value2_st);
PyStackRef_CLOSE(value1_st);
if (res_o == NULL) goto pop_2_error;
next_instr += 4;
INSTRUCTION_STATS(CALL_ISINSTANCE);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 2 cache entries */
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* isinstance(o, o2) */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
_PyStackRef cls_stackref = args[1];
_PyStackRef inst_stackref = args[0];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (retval < 0) {
goto error;
}
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(inst_stackref);
PyStackRef_CLOSE(cls_stackref);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
PREDICTED(CALL_KW);
_Py_CODEUNIT *this_instr = next_instr - 4;
(void)this_instr;
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef kwnames;
+ _PyStackRef kwnames_in;
+ _PyStackRef *func;
+ _PyStackRef *maybe_self;
+ _PyStackRef kwnames_out;
_PyStackRef res;
// _SPECIALIZE_CALL_KW
- self_or_null = &stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - oparg];
{
+ self_or_null = &stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-3 - oparg];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
- _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0]));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _Py_Specialize_CallKw(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0]));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL_KW);
#endif /* ENABLE_SPECIALIZATION */
}
/* Skip 2 cache entries */
+ // _MAYBE_EXPAND_METHOD_KW
+ {
+ kwnames_in = stack_pointer[-1];
+ args = &stack_pointer[-1 - oparg];
+ func = &stack_pointer[-3 - oparg];
+ maybe_self = &stack_pointer[-2 - oparg];
+ if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
+ PyObject *self = ((PyMethodObject *)callable_o)->im_self;
+ maybe_self[0] = PyStackRef_FromPyObjectNew(self);
+ PyObject *method = ((PyMethodObject *)callable_o)->im_func;
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(method);
+ PyStackRef_CLOSE(temp);
+ }
+ kwnames_out = kwnames_in;
+ }
// _DO_CALL_KW
- kwnames = stack_pointer[-1];
- args = &stack_pointer[-1 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ kwnames = kwnames_out;
+ args = &stack_pointer[-1 - oparg];
+ self_or_null = &stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-3 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
args--;
total_args++;
}
- else if (Py_TYPE(callable_o) == &PyMethod_Type) {
- args--;
- total_args++;
- PyObject *self = ((PyMethodObject *)callable_o)->im_self;
- args[0] = PyStackRef_FromPyObjectNew(self);
- PyObject *method = ((PyMethodObject *)callable_o)->im_func;
- args[-1] = PyStackRef_FromPyObjectNew(method);
- PyStackRef_CLOSE(callable);
- callable_o = method;
- callable = args[-1];
- }
int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);
// Check if the call can be inlined or not
if (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[-1] = kwnames;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, positional_args, kwnames_o, frame
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(kwnames);
- // Manipulate stack directly since we leave using DISPATCH_INLINED().
- STACK_SHRINK(oparg + 3);
+ // Sync stack explicitly since we leave using DISPATCH_INLINED().
+ stack_pointer += -3 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
if (new_frame == NULL) {
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
goto error;
}
}
+ stack_pointer[-1] = kwnames;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
callable_o, args_o,
positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
kwnames_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
if (opcode == INSTRUMENTED_CALL_KW) {
PyObject *arg = total_args == 0 ?
&_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]);
if (res_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, callable_o, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, callable_o, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
Py_CLEAR(res_o);
}
}
PyStackRef_CLOSE(kwnames);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
next_instr += 4;
INSTRUCTION_STATS(CALL_KW_BOUND_METHOD);
static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *null;
_PyStackRef kwnames;
- _PyStackRef method;
+ _PyStackRef *method;
_PyStackRef *self;
_PyStackRef *self_or_null;
_PyStackRef *args;
DEOPT_IF(tstate->interp->eval_frame, CALL_KW);
}
// _CHECK_METHOD_VERSION_KW
- null = &stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - oparg];
{
+ null = &stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-3 - oparg];
uint32_t func_version = read_u32(&this_instr[2].cache);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(Py_TYPE(callable_o) != &PyMethod_Type, CALL_KW);
PyObject *func = ((PyMethodObject *)callable_o)->im_func;
DEOPT_IF(!PyFunction_Check(func), CALL_KW);
DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL_KW);
}
// _EXPAND_METHOD_KW
- kwnames = stack_pointer[-1];
{
+ method = &stack_pointer[-3 - oparg];
self = &stack_pointer[-2 - oparg];
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ _PyStackRef callable_s = callable[0];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s);
assert(PyStackRef_IsNull(null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- stack_pointer[-3 - oparg] = method;
- assert(PyStackRef_FunctionCheck(method));
- PyStackRef_CLOSE(callable);
+ method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(method[0]));
+ PyStackRef_CLOSE(callable_s);
}
// flush
// _PY_FRAME_KW
- kwnames = stack_pointer[-1];
- args = &stack_pointer[-1 - oparg];
- self_or_null = &stack_pointer[-2 - oparg];
- callable = stack_pointer[-3 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ kwnames = stack_pointer[-1];
+ args = &stack_pointer[-1 - oparg];
+ self_or_null = &stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-3 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
assert(Py_TYPE(callable_o) == &PyFunction_Type);
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, positional_args, kwnames_o, frame
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(kwnames);
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
- stack_pointer += -3 - oparg;
+ stack_pointer[-3 - oparg].bits = (uintptr_t)new_frame;
+ stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (new_frame == NULL) {
goto error;
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
next_instr += 4;
INSTRUCTION_STATS(CALL_KW_NON_PY);
static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef kwnames;
_PyStackRef *self_or_null;
_PyStackRef *args;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CHECK_IS_NOT_PY_CALLABLE_KW
- callable = stack_pointer[-3 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-3 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(PyFunction_Check(callable_o), CALL_KW);
DEOPT_IF(Py_TYPE(callable_o) == &PyMethod_Type, CALL_KW);
}
// _CALL_KW_NON_PY
- kwnames = stack_pointer[-1];
- args = &stack_pointer[-1 - oparg];
- self_or_null = &stack_pointer[-2 - oparg];
{
+ kwnames = stack_pointer[-1];
+ args = &stack_pointer[-1 - oparg];
+ self_or_null = &stack_pointer[-2 - oparg];
#if TIER_ONE
assert(opcode != INSTRUMENTED_CALL);
#endif
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);
int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
callable_o, args_o,
positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
kwnames_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(kwnames);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-3 - oparg] = res;
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-3 - oparg] = res;
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 2 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-3 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_KW_PY);
static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef kwnames;
_PyStackRef *args;
DEOPT_IF(tstate->interp->eval_frame, CALL_KW);
}
// _CHECK_FUNCTION_VERSION_KW
- callable = stack_pointer[-3 - oparg];
{
+ callable = &stack_pointer[-3 - oparg];
uint32_t func_version = read_u32(&this_instr[2].cache);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(!PyFunction_Check(callable_o), CALL_KW);
PyFunctionObject *func = (PyFunctionObject *)callable_o;
DEOPT_IF(func->func_version != func_version, CALL_KW);
}
// _PY_FRAME_KW
- kwnames = stack_pointer[-1];
- args = &stack_pointer[-1 - oparg];
- self_or_null = &stack_pointer[-2 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ kwnames = stack_pointer[-1];
+ args = &stack_pointer[-1 - oparg];
+ self_or_null = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
assert(Py_TYPE(callable_o) == &PyFunction_Type);
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, positional_args, kwnames_o, frame
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(kwnames);
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
- stack_pointer += -3 - oparg;
+ stack_pointer[-3 - oparg].bits = (uintptr_t)new_frame;
+ stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (new_frame == NULL) {
goto error;
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
next_instr += 4;
INSTRUCTION_STATS(CALL_LEN);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 2 cache entries */
args = &stack_pointer[-oparg];
self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
+ callable = &stack_pointer[-2 - oparg];
/* len(o) */
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
_PyStackRef arg_stackref = args[0];
PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
Py_ssize_t len_i = PyObject_Length(arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (len_i < 0) {
goto error;
}
if (res_o == NULL) {
GOTO_ERROR(error);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(arg_stackref);
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_FAST);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_METHOD_DESCRIPTOR_FAST
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]);
DEOPT_IF(!Py_IS_TYPE(self, method->d_common.d_type), CALL);
STAT_INC(CALL, hit);
- PyCFunctionFast cfunc =
- (PyCFunctionFast)(void(*)(void))meth->ml_meth;
int nargs = total_args - 1;
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyCFunctionFast cfunc =
+ (PyCFunctionFast)(void(*)(void))meth->ml_meth;
PyObject *res_o = cfunc(self, (args_o + 1), nargs);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Clear the stack of the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
DEOPT_IF(!Py_IS_TYPE(self, d_type), CALL);
STAT_INC(CALL, hit);
int nargs = total_args - 1;
- PyCFunctionFastWithKeywords cfunc =
- (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyCFunctionFastWithKeywords cfunc =
+ (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
/* Free the arguments. */
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_NOARGS);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_METHOD_DESCRIPTOR_NOARGS
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
assert(oparg == 0 || oparg == 1);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
_Py_EnterRecursiveCallTstateUnchecked(tstate);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(self_stackref);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_O);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_METHOD_DESCRIPTOR_O
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
STAT_INC(CALL, hit);
PyCFunction cfunc = meth->ml_meth;
_Py_EnterRecursiveCallTstateUnchecked(tstate);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc,
PyStackRef_AsPyObjectBorrow(self_stackref),
PyStackRef_AsPyObjectBorrow(arg_stackref));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(self_stackref);
PyStackRef_CLOSE(arg_stackref);
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_NON_PY_GENERAL);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyStackRef res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CHECK_IS_NOT_PY_CALLABLE
- callable = stack_pointer[-2 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ callable = &stack_pointer[-2 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(PyFunction_Check(callable_o), CALL);
DEOPT_IF(Py_TYPE(callable_o) == &PyMethod_Type, CALL);
}
// _CALL_NON_PY_GENERAL
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
{
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
#if TIER_ONE
assert(opcode != INSTRUMENTED_CALL);
#endif
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
args--;
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(self_or_null[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
callable_o, args_o,
total_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
next_instr += 4;
INSTRUCTION_STATS(CALL_PY_EXACT_ARGS);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyInterpreterFrame *new_frame;
DEOPT_IF(tstate->interp->eval_frame, CALL);
}
// _CHECK_FUNCTION_VERSION
- callable = stack_pointer[-2 - oparg];
{
+ callable = &stack_pointer[-2 - oparg];
uint32_t func_version = read_u32(&this_instr[2].cache);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(!PyFunction_Check(callable_o), CALL);
PyFunctionObject *func = (PyFunctionObject *)callable_o;
DEOPT_IF(func->func_version != func_version, CALL);
}
// _CHECK_FUNCTION_EXACT_ARGS
- self_or_null = &stack_pointer[-1 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ self_or_null = &stack_pointer[-1 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
assert(PyFunction_Check(callable_o));
PyFunctionObject *func = (PyFunctionObject *)callable_o;
PyCodeObject *code = (PyCodeObject *)func->func_code;
}
// _CHECK_STACK_SPACE
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyFunctionObject *func = (PyFunctionObject *)callable_o;
PyCodeObject *code = (PyCodeObject *)func->func_code;
DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL);
DEOPT_IF(tstate->py_recursion_remaining <= 1, CALL);
}
// _INIT_CALL_PY_EXACT_ARGS
- args = &stack_pointer[-oparg];
{
+ args = &stack_pointer[-oparg];
int has_self = !PyStackRef_IsNull(self_or_null[0]);
STAT_INC(CALL, hit);
- new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame);
+ new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame);
_PyStackRef *first_non_self_local = new_frame->localsplus + has_self;
new_frame->localsplus[0] = self_or_null[0];
for (int i = 0; i < oparg; i++) {
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
next_instr += 4;
INSTRUCTION_STATS(CALL_PY_GENERAL);
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyInterpreterFrame *new_frame;
DEOPT_IF(tstate->interp->eval_frame, CALL);
}
// _CHECK_FUNCTION_VERSION
- callable = stack_pointer[-2 - oparg];
{
+ callable = &stack_pointer[-2 - oparg];
uint32_t func_version = read_u32(&this_instr[2].cache);
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(!PyFunction_Check(callable_o), CALL);
PyFunctionObject *func = (PyFunctionObject *)callable_o;
DEOPT_IF(func->func_version != func_version, CALL);
}
// _PY_FRAME_GENERAL
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
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));
- new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
+ tstate, callable[0], locals,
args, total_args, NULL, frame
);
- // The frame has stolen all the arguments from the stack,
- // so there is no need to clean them up.
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ // The frame has stolen all the arguments from the stack.
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
- if (new_frame == NULL) {
+ if (temp == NULL) {
goto error;
}
+ new_frame = temp;
}
// _SAVE_RETURN_OFFSET
{
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_STR_1
- arg = stack_pointer[-1];
- null = stack_pointer[-2];
- callable = stack_pointer[-3];
{
+ arg = stack_pointer[-1];
+ null = stack_pointer[-2];
+ callable = stack_pointer[-3];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg);
assert(oparg == 1);
DEOPT_IF(!PyStackRef_IsNull(null), CALL);
DEOPT_IF(callable_o != (PyObject *)&PyUnicode_Type, CALL);
STAT_INC(CALL, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(arg);
if (PyStackRef_IsNull(res)) goto pop_3_error;
}
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-3] = res;
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) goto pop_2_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-3] = res;
/* Skip 1 cache entry */
/* Skip 2 cache entries */
// _CALL_TUPLE_1
- arg = stack_pointer[-1];
- null = stack_pointer[-2];
- callable = stack_pointer[-3];
{
+ arg = stack_pointer[-1];
+ null = stack_pointer[-2];
+ callable = stack_pointer[-3];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg);
assert(oparg == 1);
DEOPT_IF(!PyStackRef_IsNull(null), CALL);
DEOPT_IF(callable_o != (PyObject *)&PyTuple_Type, CALL);
STAT_INC(CALL, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(arg);
if (PyStackRef_IsNull(res)) goto pop_3_error;
}
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-3] = res;
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) goto pop_2_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-3] = res;
exc_value_st = stack_pointer[-2];
PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st);
PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
PyStackRef_CLOSE(exc_value_st);
PyStackRef_CLOSE(match_type_st);
}
PyObject *match_o = NULL;
PyObject *rest_o = NULL;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PyEval_ExceptionGroupMatch(exc_value, match_type,
&match_o, &rest_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(exc_value_st);
PyStackRef_CLOSE(match_type_st);
if (res < 0) goto pop_2_error;
assert((match_o == NULL) == (rest_o == NULL));
if (match_o == NULL) goto pop_2_error;
if (!Py_IsNone(match_o)) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyErr_SetHandledException(match_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
rest = PyStackRef_FromPyObjectSteal(rest_o);
match = PyStackRef_FromPyObjectSteal(match_o);
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyExceptionInstance_Check(left_o));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyEval_CheckExceptTypeValid(tstate, right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
PyStackRef_CLOSE(right);
if (true) goto pop_1_error;
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = PyErr_GivenExceptionMatches(left_o, right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(right);
b = res ? PyStackRef_True : PyStackRef_False;
stack_pointer[-1] = b;
PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st);
assert(throwflag);
assert(exc_value && PyExceptionInstance_Check(exc_value));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (matches) {
+ none = PyStackRef_None;
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
- stack_pointer[-2] = value;
PyStackRef_CLOSE(sub_iter_st);
PyStackRef_CLOSE(last_sent_val_st);
PyStackRef_CLOSE(exc_value_st);
- none = PyStackRef_None;
}
else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
monitor_reraise(tstate, frame, this_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
goto exception_unwind;
}
stack_pointer[-3] = none;
+ stack_pointer[-2] = value;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
_PyStackRef right;
_PyStackRef res;
// _SPECIALIZE_COMPARE_OP
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_CompareOp(left, right, next_instr, oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(COMPARE_OP);
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert((oparg >> 5) <= Py_GE);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
if (res_o == NULL) goto pop_2_error;
if (oparg & 16) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res_bool = PyObject_IsTrue(res_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(res_o);
- if (res_bool < 0) goto pop_2_error;
+ if (res_bool < 0) goto error;
res = res_bool ? PyStackRef_True : PyStackRef_False;
}
else {
res = PyStackRef_FromPyObjectSteal(res_o);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_FLOAT
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyFloat_CheckExact(left_o), COMPARE_OP);
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_INT
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyLong_CheckExact(left_o), COMPARE_OP);
_PyStackRef right;
_PyStackRef res;
// _GUARD_BOTH_UNICODE
- right = stack_pointer[-1];
- left = stack_pointer[-2];
{
+ right = stack_pointer[-1];
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyUnicode_CheckExact(left_o), COMPARE_OP);
_PyStackRef right;
_PyStackRef b;
// _SPECIALIZE_CONTAINS_OP
- right = stack_pointer[-1];
{
+ right = stack_pointer[-1];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_ContainsOp(right, next_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CONTAINS_OP);
#endif /* ENABLE_SPECIALIZATION */
}
// _CONTAINS_OP
- left = stack_pointer[-2];
{
+ left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = PySequence_Contains(right_o, left_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
if (res < 0) goto pop_2_error;
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
DEOPT_IF(!PyDict_CheckExact(right_o), CONTAINS_OP);
STAT_INC(CONTAINS_OP, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = PyDict_Contains(right_o, left_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
if (res < 0) goto pop_2_error;
DEOPT_IF(!(PySet_CheckExact(right_o) || PyFrozenSet_CheckExact(right_o)), CONTAINS_OP);
STAT_INC(CONTAINS_OP, hit);
// Note: both set and frozenset use the same seq_contains method!
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PySet_Contains((PySetObject *)right_o, left_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
if (res < 0) goto pop_2_error;
conversion_func conv_fn;
assert(oparg >= FVC_STR && oparg <= FVC_ASCII);
conv_fn = _PyEval_ConversionFuncs[oparg];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
if (result_o == NULL) goto pop_1_error;
result = PyStackRef_FromPyObjectSteal(result_o);
_PyStackRef owner;
owner = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
if (err) goto pop_1_error;
stack_pointer += -1;
// Fortunately we don't need its superpower.
PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL);
if (oldobj == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
goto error;
}
Py_DECREF(oldobj);
INSTRUCTION_STATS(DELETE_FAST);
_PyStackRef v = GETLOCAL(oparg);
if (PyStackRef_IsNull(v)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (1) goto error;
}
SETLOCAL(oparg, PyStackRef_NULL);
next_instr += 1;
INSTRUCTION_STATS(DELETE_GLOBAL);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyDict_Pop(GLOBALS(), name, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// Can't use ERROR_IF here.
if (err < 0) {
goto error;
}
if (err == 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
goto error;
}
DISPATCH();
PyObject *ns = LOCALS();
int err;
if (ns == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals when deleting %R", name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
goto error;
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_DelItem(ns, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// Can't use ERROR_IF here.
if (err != 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG,
name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
goto error;
}
DISPATCH();
sub = stack_pointer[-1];
container = stack_pointer[-2];
/* del container[sub] */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container),
PyStackRef_AsPyObjectBorrow(sub));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
if (err) goto pop_2_error;
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict);
PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyDict_MergeEx(dict_o, update_o, 2);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatKwargsError(tstate, callable_o, update_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(update);
if (true) goto pop_1_error;
}
dict = stack_pointer[-2 - (oparg - 1)];
PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict);
PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyDict_Update(dict_o, update_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (matches) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
"'%.200s' object is not a mapping",
Py_TYPE(update_o)->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(update);
if (true) goto pop_1_error;
awaitable_st = stack_pointer[-2];
PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st);
assert(exc && PyExceptionInstance_Check(exc));
- if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (matches) {
PyStackRef_CLOSE(awaitable_st);
PyStackRef_CLOSE(exc_st);
}
else {
Py_INCREF(exc);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetRaisedException(tstate, exc);
monitor_reraise(tstate, frame, this_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
goto exception_unwind;
}
stack_pointer += -2;
INSTRUCTION_STATS(END_SEND);
_PyStackRef receiver;
_PyStackRef value;
+ _PyStackRef val;
value = stack_pointer[-1];
receiver = stack_pointer[-2];
(void)receiver;
+ val = value;
PyStackRef_CLOSE(receiver);
- stack_pointer[-2] = value;
+ stack_pointer[-2] = val;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
should_be_none = stack_pointer[-1];
assert(STACK_LEVEL() == 2);
if (!PyStackRef_Is(should_be_none, PyStackRef_None)) {
+ _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);
goto error;
}
stack_pointer += -1;
/* If value is a unicode object, then we know the result
* of format(value) is value itself. */
if (!PyUnicode_CheckExact(value_o)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
if (PyStackRef_IsNull(res)) goto pop_1_error;
}
_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));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
PyStackRef_CLOSE(fmt_spec);
if (res_o == NULL) goto pop_2_error;
_PyStackRef iter;
_PyStackRef next;
// _SPECIALIZE_FOR_ITER
- iter = stack_pointer[-1];
{
+ iter = stack_pointer[-1];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_ForIter(iter, next_instr, oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(FOR_ITER);
{
/* before: [iter]; after: [iter, iter()] *or* [] (and jump over END_FOR.) */
PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (next_o == NULL) {
- next = PyStackRef_NULL;
if (_PyErr_Occurred(tstate)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (!matches) {
goto error;
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_MonitorRaise(tstate, frame, this_instr);
_PyErr_Clear(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
/* iterator ended normally */
assert(next_instr[oparg].op.code == END_FOR ||
DEOPT_IF(tstate->interp->eval_frame, FOR_ITER);
}
// _FOR_ITER_GEN_FRAME
- iter = stack_pointer[-1];
{
+ iter = stack_pointer[-1];
PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter);
DEOPT_IF(Py_TYPE(gen) != &PyGen_Type, FOR_ITER);
DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, FOR_ITER);
frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg);
}
// _PUSH_FRAME
- new_frame = gen_frame;
{
+ new_frame = gen_frame;
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
_PyStackRef next;
/* Skip 1 cache entry */
// _ITER_CHECK_LIST
- iter = stack_pointer[-1];
{
+ iter = stack_pointer[-1];
DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(iter)) != &PyListIter_Type, FOR_ITER);
}
// _ITER_JUMP_LIST
assert(seq);
assert(it->it_index < PyList_GET_SIZE(seq));
next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++));
- stack_pointer[0] = next;
}
+ stack_pointer[0] = next;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
_PyStackRef next;
/* Skip 1 cache entry */
// _ITER_CHECK_RANGE
- iter = stack_pointer[-1];
{
+ iter = stack_pointer[-1];
_PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter);
DEOPT_IF(Py_TYPE(r) != &PyRangeIter_Type, FOR_ITER);
}
_PyStackRef next;
/* Skip 1 cache entry */
// _ITER_CHECK_TUPLE
- iter = stack_pointer[-1];
{
+ iter = stack_pointer[-1];
DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(iter)) != &PyTupleIter_Type, FOR_ITER);
}
// _ITER_JUMP_TUPLE
assert(seq);
assert(it->it_index < PyTuple_GET_SIZE(seq));
next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++));
- stack_pointer[0] = next;
}
+ stack_pointer[0] = next;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
getter = type->tp_as_async->am_aiter;
}
if (getter == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' requires an object with "
"__aiter__ method, got %.100s",
type->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(obj);
if (true) goto pop_1_error;
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
iter_o = (*getter)(obj_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(obj);
if (iter_o == NULL) goto pop_1_error;
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' received an object from __aiter__ "
"that does not implement __anext__: %.100s",
Py_TYPE(iter_o)->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(iter_o);
- if (true) goto pop_1_error;
+ if (true) goto error;
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
stack_pointer[-1] = iter;
_PyStackRef aiter;
_PyStackRef awaitable;
aiter = stack_pointer[-1];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (awaitable_o == NULL) {
goto error;
}
_PyStackRef iterable;
_PyStackRef iter;
iterable = stack_pointer[-1];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
if (iter_o == NULL) goto pop_1_error;
iter = PyStackRef_FromPyObjectSteal(iter_o);
_PyStackRef iter;
iterable = stack_pointer[-1];
/* before: [obj]; after [getiter(obj)] */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable)));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
if (PyStackRef_IsNull(iter)) goto pop_1_error;
stack_pointer[-1] = iter;
_PyStackRef len;
obj = stack_pointer[-1];
// PUSH(len(TOS))
+ _PyFrame_SetStackPointer(frame, stack_pointer);
Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (len_i < 0) goto error;
PyObject *len_o = PyLong_FromSsize_t(len_i);
if (len_o == NULL) goto error;
if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
/* and it is used in a 'yield from' expression of a
regular generator. */
+ _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);
goto error;
}
iter = iterable;
}
- else if (PyGen_CheckExact(iterable_o)) {
- iter = iterable;
- }
else {
- /* `iterable` is not a generator. */
- iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o));
- if (PyStackRef_IsNull(iter)) {
- goto error;
+ if (PyGen_CheckExact(iterable_o)) {
+ iter = iterable;
+ }
+ else {
+ /* `iterable` is not a generator. */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (PyStackRef_IsNull(iter)) {
+ goto error;
+ }
+ PyStackRef_CLOSE(iterable);
}
- PyStackRef_CLOSE(iterable);
}
stack_pointer[-1] = iter;
DISPATCH();
_PyStackRef res;
from = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) goto error;
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[0] = res;
fromlist = stack_pointer[-1];
level = stack_pointer[-2];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_ImportName(tstate, frame, name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(level);
PyStackRef_CLOSE(fromlist);
if (res_o == NULL) goto pop_2_error;
(void)this_instr;
next_instr += 4;
INSTRUCTION_STATS(INSTRUMENTED_CALL);
- _PyStackRef callable;
+ _PyStackRef *callable;
_PyStackRef *self_or_null;
_PyStackRef *args;
- _PyStackRef func;
+ _PyStackRef *func;
_PyStackRef *maybe_self;
_PyStackRef res;
/* Skip 3 cache entries */
// _MAYBE_EXPAND_METHOD
- args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = stack_pointer[-2 - oparg];
{
+ args = &stack_pointer[-oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
+ func = &stack_pointer[-2 - oparg];
maybe_self = &stack_pointer[-1 - oparg];
- if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) {
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
PyObject *self = ((PyMethodObject *)callable_o)->im_self;
maybe_self[0] = PyStackRef_FromPyObjectNew(self);
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
- func = PyStackRef_FromPyObjectNew(method);
- stack_pointer[-2 - oparg] = func;
- PyStackRef_CLOSE(callable);
- }
- else {
- func = callable;
+ _PyStackRef temp = callable[0];
+ func[0] = PyStackRef_FromPyObjectNew(method);
+ PyStackRef_CLOSE(temp);
}
}
// _MONITOR_CALL
{
+ args = &stack_pointer[-oparg];
+ maybe_self = &stack_pointer[-1 - oparg];
+ func = &stack_pointer[-2 - oparg];
int is_meth = !PyStackRef_IsNull(maybe_self[0]);
- PyObject *function = PyStackRef_AsPyObjectBorrow(func);
+ PyObject *function = PyStackRef_AsPyObjectBorrow(func[0]);
PyObject *arg0;
if (is_meth) {
arg0 = PyStackRef_AsPyObjectBorrow(maybe_self[0]);
}
- else if (oparg) {
- arg0 = PyStackRef_AsPyObjectBorrow(args[0]);
- }
else {
- arg0 = &_PyInstrumentation_MISSING;
+ if (oparg) {
+ arg0 = PyStackRef_AsPyObjectBorrow(args[0]);
+ }
+ else {
+ arg0 = &_PyInstrumentation_MISSING;
+ }
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, function, arg0
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) goto error;
}
// _DO_CALL
- self_or_null = maybe_self;
- callable = func;
{
- PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable);
+ self_or_null = maybe_self;
+ callable = func;
+ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
if (!PyStackRef_IsNull(self_or_null[0])) {
{
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
- tstate, callable, locals,
+ tstate, callable[0], locals,
args, total_args, NULL, frame
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// Manipulate stack directly since we leave using DISPATCH_INLINED().
- STACK_SHRINK(oparg + 2);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
if (new_frame == NULL) {
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(args, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
goto error;
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
callable_o, args_o,
total_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
if (opcode == INSTRUMENTED_CALL) {
PyObject *arg = total_args == 0 ?
&_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]);
if (res_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, callable_o, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, callable_o, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
Py_CLEAR(res_o);
}
}
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable);
+ PyStackRef_CLOSE(callable[0]);
for (int i = 0; i < total_args; i++) {
PyStackRef_CLOSE(args[i]);
}
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
- if (err != 0) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err != 0) goto error;
+ stack_pointer += 1 + oparg;
+ assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[-2 - oparg] = res;
PyObject *function = PyStackRef_AsPyObjectBorrow(PEEK(oparg + 3));
PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING
: PyStackRef_AsPyObjectBorrow(PEEK(total_args + 1));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, function, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) goto error;
PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter);
GO_TO_INSTRUCTION(CALL_KW);
/* Need to create a fake StopIteration error here,
* to conform to PEP 380 */
if (PyStackRef_GenCheck(receiver)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
goto error;
}
INSTRUCTION_STATS(INSTRUMENTED_END_SEND);
_PyStackRef receiver;
_PyStackRef value;
+ _PyStackRef val;
value = stack_pointer[-1];
receiver = stack_pointer[-2];
PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);
if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
goto error;
}
}
+ val = value;
PyStackRef_CLOSE(receiver);
- stack_pointer[-2] = value;
+ stack_pointer[-2] = val;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
_Py_CODEUNIT *target;
_PyStackRef iter_stackref = TOP();
PyObject *iter = PyStackRef_AsPyObjectBorrow(iter_stackref);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *next = (*Py_TYPE(iter)->tp_iternext)(iter);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (next != NULL) {
PUSH(PyStackRef_FromPyObjectSteal(next));
target = next_instr;
}
else {
if (_PyErr_Occurred(tstate)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (!matches) {
goto error;
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_MonitorRaise(tstate, frame, this_instr);
_PyErr_Clear(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
/* iterator ended normally */
assert(next_instr[oparg].op.code == END_FOR ||
(void)this_instr;
next_instr += 1;
INSTRUCTION_STATS(INSTRUMENTED_INSTRUCTION);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int next_opcode = _Py_call_instrumentation_instruction(
tstate, frame, this_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (next_opcode < 0) goto error;
next_instr = this_instr;
if (_PyOpcode_Caches[next_opcode]) {
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) goto error;
}
}
// don't want to specialize instrumented instructions
PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter);
GO_TO_INSTRUCTION(LOAD_SUPER_ATTR);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
}
TARGET(INSTRUMENTED_POP_JUMP_IF_FALSE) {
uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK;
uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version);
if (code_version != global_version) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
goto error;
}
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate); \
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) goto error;
}
}
// _LOAD_CONST
{
value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));
- stack_pointer[0] = value;
}
// _RETURN_VALUE_EVENT
- val = value;
{
+ val = value;
+ stack_pointer[0] = val;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_RETURN,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) goto error;
}
// _RETURN_VALUE
- retval = val;
{
+ retval = val;
#if TIER_ONE
assert(frame != &entry_frame);
#endif
+ _PyStackRef temp = retval;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(EMPTY());
_Py_LeaveRecursiveCallPy(tstate);
_PyInterpreterFrame *dying = frame;
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
LOAD_IP(frame->return_offset);
- res = retval;
+ res = temp;
LLTRACE_RESUME_FRAME();
}
stack_pointer[0] = res;
_PyStackRef retval;
_PyStackRef res;
// _RETURN_VALUE_EVENT
- val = stack_pointer[-1];
{
+ val = stack_pointer[-1];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_RETURN,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) goto error;
}
// _RETURN_VALUE
- retval = val;
{
+ retval = val;
#if TIER_ONE
assert(frame != &entry_frame);
#endif
+ _PyStackRef temp = retval;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *dying = frame;
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
LOAD_IP(frame->return_offset);
- res = retval;
+ res = temp;
LLTRACE_RESUME_FRAME();
}
stack_pointer[0] = res;
_PyStackRef retval;
_PyStackRef value;
// _YIELD_VALUE_EVENT
- val = stack_pointer[-1];
{
- SAVE_SP();
+ val = stack_pointer[-1];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_YIELD,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
- LOAD_SP();
- if (err) goto error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err) {
+ goto error;
+ }
if (frame->instr_ptr != this_instr) {
next_instr = frame->instr_ptr;
DISPATCH();
}
}
// _YIELD_VALUE
- retval = val;
{
+ retval = val;
// NOTE: It's important that YIELD_VALUE never raises an exception!
// The compiler treats any exception raised here as a failed close()
// or throw() call.
assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1);
assert(oparg == 0 || oparg == 1);
gen->gi_frame_state = FRAME_SUSPENDED + oparg;
+ _PyStackRef temp = retval;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(INLINE_CACHE_ENTRIES_SEND == INLINE_CACHE_ENTRIES_FOR_ITER);
#if TIER_ONE
assert(frame->instr_ptr->op.code == INSTRUMENTED_LINE ||
- frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR);
+ frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR);
#endif
+ stack_pointer = _PyFrame_GetStackPointer(frame);
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
- LOAD_SP();
- value = retval;
+ value = temp;
LLTRACE_RESUME_FRAME();
}
stack_pointer[0] = value;
assert(!_PyErr_Occurred(tstate));
tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;
return PyStackRef_AsPyObjectSteal(retval);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
}
TARGET(IS_OP) {
// _CHECK_PERIODIC
{
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
- QSBR_QUIESCENT_STATE(tstate); \
+ QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) goto error;
}
}
start--;
}
_PyExecutorObject *executor;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int optimized = _PyOptimizer_Optimize(frame, start, stack_pointer, &executor, 0);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (optimized < 0) goto error;
if (optimized) {
assert(tstate->previous_executor == NULL);
_PyStackRef v;
v = stack_pointer[-1];
list = stack_pointer[-2 - (oparg-1)];
- if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
- PyStackRef_AsPyObjectSteal(v)) < 0) goto pop_1_error;
+ int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
+ PyStackRef_AsPyObjectSteal(v));
+ if (err < 0) goto pop_1_error;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
list_st = stack_pointer[-2 - (oparg-1)];
PyObject *list = PyStackRef_AsPyObjectBorrow(list_st);
PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (none_val == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (matches &&
(Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
{
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Clear(tstate);
_PyErr_Format(tstate, PyExc_TypeError,
"Value after * must be an iterable, not %.200s",
Py_TYPE(iterable)->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(iterable_st);
if (true) goto pop_1_error;
_PyStackRef attr;
_PyStackRef self_or_null = PyStackRef_NULL;
// _SPECIALIZE_LOAD_ATTR
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_LoadAttr(owner, next_instr, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_ATTR);
if (oparg & 1) {
/* Designed to work in tandem with CALL, pushes two values. */
attr_o = NULL;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (is_meth) {
/* We can bypass temporary bound method object.
meth is unbound method and obj is self.
}
else {
/* Classic, pushes one value. */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
if (attr_o == NULL) goto pop_1_error;
+ /* We need to define self_or_null on all paths */
+ self_or_null = PyStackRef_NULL;
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
}
_PyStackRef null = PyStackRef_NULL;
/* Skip 1 cache entry */
// _CHECK_ATTR_CLASS
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
DEOPT_IF(!PyType_Check(owner_o), LOAD_ATTR);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
null = PyStackRef_NULL;
PyStackRef_CLOSE(owner);
}
+ stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
_PyStackRef null = PyStackRef_NULL;
/* Skip 1 cache entry */
// _CHECK_ATTR_CLASS
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
DEOPT_IF(!PyType_Check(owner_o), LOAD_ATTR);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
null = PyStackRef_NULL;
PyStackRef_CLOSE(owner);
}
+ stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
_PyStackRef null = PyStackRef_NULL;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
_PyStackRef self = PyStackRef_NULL;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
self = owner;
}
+ stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyStackRef self = PyStackRef_NULL;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
self = owner;
}
+ stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyStackRef self = PyStackRef_NULL;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
assert(descr != NULL);
assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR));
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
self = owner;
}
+ stack_pointer[-1] = attr;
stack_pointer[0] = self;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyStackRef null = PyStackRef_NULL;
/* Skip 1 cache entry */
// _CHECK_ATTR_MODULE
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t dict_version = read_u32(&this_instr[2].cache);
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
DEOPT_IF(!PyModule_CheckExact(owner_o), LOAD_ATTR);
_PyStackRef attr;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
assert(descr != NULL);
PyStackRef_CLOSE(owner);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
}
+ stack_pointer[-1] = attr;
DISPATCH();
}
_PyStackRef attr;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
assert(descr != NULL);
PyStackRef_CLOSE(owner);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
}
+ stack_pointer[-1] = attr;
DISPATCH();
}
DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR);
}
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
_PyStackRef null = PyStackRef_NULL;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
STAT_INC(LOAD_ATTR, hit);
null = PyStackRef_NULL;
attr = PyStackRef_FromPyObjectNew(attr_o);
- stack_pointer[-1] = attr;
PyStackRef_CLOSE(owner);
}
/* Skip 5 cache entries */
+ stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
_PyStackRef null = PyStackRef_NULL;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
INSTRUCTION_STATS(LOAD_BUILD_CLASS);
_PyStackRef bc;
PyObject *bc_o;
- if (PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o) < 0) goto error;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err < 0) goto error;
if (bc_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetString(tstate, PyExc_NameError,
"__build_class__ not found");
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (true) goto error;
}
bc = PyStackRef_FromPyObjectSteal(bc_o);
INSTRUCTION_STATS(LOAD_COMMON_CONSTANT);
_PyStackRef value;
// Keep in sync with _common_constants in opcode.py
- switch(oparg) {
- case CONSTANT_ASSERTIONERROR:
- value = PyStackRef_FromPyObjectImmortal(PyExc_AssertionError);
- break;
- case CONSTANT_NOTIMPLEMENTEDERROR:
- value = PyStackRef_FromPyObjectImmortal(PyExc_NotImplementedError);
- break;
- default:
- Py_FatalError("bad LOAD_COMMON_CONSTANT oparg");
+ // If we ever have more than two constants, use a lookup table
+ PyObject *val;
+ if (oparg == CONSTANT_ASSERTIONERROR) {
+ val = PyExc_AssertionError;
+ }
+ else {
+ assert(oparg == CONSTANT_NOTIMPLEMENTEDERROR);
+ val = PyExc_NotImplementedError;
}
+ value = PyStackRef_FromPyObjectImmortal(val);
stack_pointer[0] = value;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
PyObject *value_o = PyCell_GetRef(cell);
if (value_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (true) goto error;
}
value = PyStackRef_FromPyObjectSteal(value_o);
_PyStackRef value;
_PyStackRef value_s = GETLOCAL(oparg);
if (PyStackRef_IsNull(value_s)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (1) goto error;
}
value = PyStackRef_DUP(value_s);
assert(class_dict);
assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus);
name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(class_dict, name, &value_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
goto error;
}
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
value_o = PyCell_GetRef(cell);
if (value_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
goto error;
}
}
mod_or_class_dict = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
PyObject *v_o;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o);
- if (err < 0) {
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ PyStackRef_CLOSE(mod_or_class_dict);
+ if (err < 0) goto pop_1_error;
if (v_o == NULL) {
if (PyDict_CheckExact(GLOBALS())
&& PyDict_CheckExact(BUILTINS()))
{
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
v_o = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(),
(PyDictObject *)BUILTINS(),
name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (v_o == NULL) {
if (!_PyErr_Occurred(tstate)) {
/* _PyDict_LoadGlobal() returns NULL without raising
* an exception if the key doesn't exist */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
goto error;
}
else {
/* Slow-path if globals or builtins is not a dict */
/* namespace 1: globals */
- if (PyMapping_GetOptionalItem(GLOBALS(), name, &v_o) < 0) goto pop_1_error;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int err = PyMapping_GetOptionalItem(GLOBALS(), name, &v_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err < 0) goto error;
if (v_o == NULL) {
/* namespace 2: builtins */
- if (PyMapping_GetOptionalItem(BUILTINS(), name, &v_o) < 0) goto pop_1_error;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int err = PyMapping_GetOptionalItem(BUILTINS(), name, &v_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err < 0) goto error;
if (v_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(
tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
- if (true) goto pop_1_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (true) goto error;
}
}
}
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
- PyStackRef_CLOSE(mod_or_class_dict);
v = PyStackRef_FromPyObjectSteal(v_o);
stack_pointer[-1] = v;
DISPATCH();
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_GLOBAL);
{
res = &stack_pointer[0];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(*res)) goto error;
null = PyStackRef_NULL;
}
_PyStackRef locals;
PyObject *l = LOCALS();
if (l == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetString(tstate, PyExc_SystemError,
"no locals found");
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (true) goto error;
}
locals = PyStackRef_FromPyObjectNew(l);
INSTRUCTION_STATS(LOAD_NAME);
_PyStackRef v;
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *v_o = _PyEval_LoadName(tstate, frame, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (v_o == NULL) goto error;
v = PyStackRef_FromPyObjectSteal(v_o);
stack_pointer[0] = v;
PyObject *owner_o = PyStackRef_AsPyObjectSteal(owner);
PyObject *name = _Py_SpecialMethods[oparg].name;
PyObject *self_or_null_o;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(attr)) {
if (!_PyErr_Occurred(tstate)) {
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
_Py_SpecialMethods[oparg].error,
Py_TYPE(owner_o)->tp_name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
}
}
- if (PyStackRef_IsNull(attr)) goto pop_1_error;
+ if (PyStackRef_IsNull(attr)) {
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
+ }
self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o);
- stack_pointer[-1] = attr;
- stack_pointer[0] = self_or_null;
- stack_pointer += 1;
+ stack_pointer[0] = attr;
+ stack_pointer[1] = self_or_null;
+ stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyStackRef attr;
_PyStackRef null = PyStackRef_NULL;
// _SPECIALIZE_LOAD_SUPER_ATTR
- class_st = stack_pointer[-2];
- global_super_st = stack_pointer[-3];
{
+ class_st = stack_pointer[-2];
+ global_super_st = stack_pointer[-3];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
int load_method = oparg & 1;
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_LoadSuperAttr(global_super_st, class_st, next_instr, load_method);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_SUPER_ATTR);
#endif /* ENABLE_SPECIALIZATION */
}
// _LOAD_SUPER_ATTR
- self_st = stack_pointer[-1];
{
+ self_st = stack_pointer[-1];
PyObject *global_super = PyStackRef_AsPyObjectBorrow(global_super_st);
PyObject *class = PyStackRef_AsPyObjectBorrow(class_st);
PyObject *self = PyStackRef_AsPyObjectBorrow(self_st);
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, global_super, arg);
- if (err) goto pop_3_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err) {
+ PyStackRef_CLOSE(global_super_st);
+ PyStackRef_CLOSE(class_st);
+ PyStackRef_CLOSE(self_st);
+ if (true) goto pop_3_error;
+ }
}
// we make no attempt to optimize here; specializations should
// handle any case whose performance we care about
PyObject *stack[] = {class, self};
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
if (super == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, global_super, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, global_super, arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
Py_CLEAR(super);
}
PyStackRef_CLOSE(self_st);
if (super == NULL) goto pop_3_error;
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
attr = PyStackRef_FromPyObjectSteal(PyObject_GetAttr(super, name));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(super);
- if (PyStackRef_IsNull(attr)) goto pop_3_error;
+ if (PyStackRef_IsNull(attr)) goto error;
null = PyStackRef_NULL;
}
- stack_pointer[-3] = attr;
- if (oparg & 1) stack_pointer[-2] = null;
- stack_pointer += -2 + (oparg & 1);
+ stack_pointer[0] = attr;
+ if (oparg & 1) stack_pointer[1] = null;
+ stack_pointer += 1 + (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
DEOPT_IF(!PyType_Check(class), LOAD_SUPER_ATTR);
STAT_INC(LOAD_SUPER_ATTR, hit);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(global_super_st);
PyStackRef_CLOSE(class_st);
PyStackRef_CLOSE(self_st);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
PyTypeObject *cls = (PyTypeObject *)class;
int method_found = 0;
+ _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);
PyStackRef_CLOSE(global_super_st);
PyStackRef_CLOSE(class_st);
if (attr_o == NULL) {
_PyStackRef func;
codeobj_st = stack_pointer[-1];
PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyFunctionObject *func_obj = (PyFunctionObject *)
PyFunction_New(codeobj, GLOBALS());
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(codeobj_st);
- if (func_obj == NULL) {
- goto error;
- }
+ if (func_obj == NULL) goto pop_1_error;
_PyFunction_SetVersion(
func_obj, ((PyCodeObject *)codeobj)->co_version);
func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);
assert(PyDict_CheckExact(dict));
/* dict[key] = value */
// Do not DECREF INPUTS because the function steals the references
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyDict_SetItem_Take2(
(PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(key),
PyStackRef_AsPyObjectSteal(value)
);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) goto pop_2_error;
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
// Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or
// None on failure.
assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names)));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attrs_o = _PyEval_MatchClass(tstate,
PyStackRef_AsPyObjectBorrow(subject),
PyStackRef_AsPyObjectBorrow(type), oparg,
PyStackRef_AsPyObjectBorrow(names));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(subject);
PyStackRef_CLOSE(type);
PyStackRef_CLOSE(names);
keys = stack_pointer[-1];
subject = stack_pointer[-2];
// On successful match, PUSH(values). Otherwise, PUSH(None).
+ _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) goto error;
values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o);
stack_pointer[0] = values_or_none;
_PyStackRef exc_value;
exc_value = stack_pointer[-1];
_PyErr_StackItem *exc_info = tstate->exc_info;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
Py_XSETREF(exc_info->exc_value,
PyStackRef_Is(exc_value, PyStackRef_None)
? NULL : PyStackRef_AsPyObjectSteal(exc_value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
_PyStackRef cond;
/* Skip 1 cache entry */
// _IS_NONE
- value = stack_pointer[-1];
{
+ value = stack_pointer[-1];
if (PyStackRef_Is(value, PyStackRef_None)) {
b = PyStackRef_True;
}
}
}
// _POP_JUMP_IF_TRUE
- cond = b;
{
+ cond = b;
assert(PyStackRef_BoolCheck(cond));
int flag = PyStackRef_Is(cond, PyStackRef_True);
#if ENABLE_SPECIALIZATION
_PyStackRef cond;
/* Skip 1 cache entry */
// _IS_NONE
- value = stack_pointer[-1];
{
+ value = stack_pointer[-1];
if (PyStackRef_Is(value, PyStackRef_None)) {
b = PyStackRef_True;
}
}
}
// _POP_JUMP_IF_FALSE
- cond = b;
{
+ cond = b;
assert(PyStackRef_BoolCheck(cond));
int flag = PyStackRef_Is(cond, PyStackRef_False);
#if ENABLE_SPECIALIZATION
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(PUSH_EXC_INFO);
- _PyStackRef new_exc;
+ _PyStackRef exc;
_PyStackRef prev_exc;
- new_exc = stack_pointer[-1];
+ _PyStackRef new_exc;
+ exc = stack_pointer[-1];
_PyErr_StackItem *exc_info = tstate->exc_info;
if (exc_info->exc_value != NULL) {
prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value);
else {
prev_exc = PyStackRef_None;
}
- assert(PyStackRef_ExceptionInstanceCheck(new_exc));
- exc_info->exc_value = PyStackRef_AsPyObjectNew(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;
INSTRUCTION_STATS(RAISE_VARARGS);
_PyStackRef *args;
args = &stack_pointer[-oparg];
- PyObject *cause = NULL, *exc = NULL;
- switch (oparg) {
- case 2:
- cause = PyStackRef_AsPyObjectSteal(args[1]);
- _Py_FALLTHROUGH;
- case 1:
- exc = PyStackRef_AsPyObjectSteal(args[0]);
- _Py_FALLTHROUGH;
- case 0:
- if (do_raise(tstate, exc, cause)) {
- assert(oparg == 0);
- monitor_reraise(tstate, frame, this_instr);
- goto exception_unwind;
- }
- break;
- default:
- _PyErr_SetString(tstate, PyExc_SystemError,
- "bad RAISE_VARARGS oparg");
- break;
- }
- if (true) {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
+ assert(oparg < 3);
+ PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL;
+ PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL;
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int err = do_raise(tstate, exc, cause);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err) {
+ assert(oparg == 0);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ monitor_reraise(tstate, frame, this_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ goto exception_unwind;
}
+ if (true) goto error;
}
TARGET(RERAISE) {
_PyStackRef exc_st;
exc_st = stack_pointer[-1];
values = &stack_pointer[-1 - oparg];
- PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st);
+ PyObject *exc = PyStackRef_AsPyObjectSteal(exc_st);
assert(oparg >= 0 && oparg <= 2);
if (oparg) {
PyObject *lasti = PyStackRef_AsPyObjectBorrow(values[0]);
assert(!_PyErr_Occurred(tstate));
}
else {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int");
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ Py_DECREF(exc);
goto error;
}
}
assert(exc && PyExceptionInstance_Check(exc));
- Py_INCREF(exc);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetRaisedException(tstate, exc);
monitor_reraise(tstate, frame, this_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
goto exception_unwind;
}
uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK;
uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version);
if (code_version != global_version) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
goto error;
}
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate); \
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err != 0) goto error;
}
}
// _LOAD_CONST
{
value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));
- stack_pointer[0] = value;
}
// _RETURN_VALUE
- retval = value;
{
+ retval = value;
#if TIER_ONE
assert(frame != &entry_frame);
#endif
+ _PyStackRef temp = retval;
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(EMPTY());
_Py_LeaveRecursiveCallPy(tstate);
_PyInterpreterFrame *dying = frame;
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
LOAD_IP(frame->return_offset);
- res = retval;
+ res = temp;
LLTRACE_RESUME_FRAME();
}
stack_pointer[0] = res;
_PyStackRef res;
assert(PyStackRef_FunctionCheck(frame->f_funcobj));
PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
- if (gen == NULL) {
- goto error;
- }
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (gen == NULL) goto error;
assert(EMPTY());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *gen_frame = &gen->gi_iframe;
gen->gi_frame_state = FRAME_CREATED;
gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
_Py_LeaveRecursiveCallPy(tstate);
- res = PyStackRef_FromPyObjectSteal((PyObject *)gen);
_PyInterpreterFrame *prev = frame->previous;
_PyThreadState_PopFrame(tstate, frame);
frame = tstate->current_frame = prev;
LOAD_IP(frame->return_offset);
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ res = PyStackRef_FromPyObjectSteal((PyObject *)gen);
LLTRACE_RESUME_FRAME();
stack_pointer[0] = res;
stack_pointer += 1;
#if TIER_ONE
assert(frame != &entry_frame);
#endif
+ _PyStackRef temp = retval;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *dying = frame;
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
LOAD_IP(frame->return_offset);
- res = retval;
+ res = temp;
LLTRACE_RESUME_FRAME();
stack_pointer[0] = res;
stack_pointer += 1;
_PyStackRef v;
_PyStackRef retval;
// _SPECIALIZE_SEND
- receiver = stack_pointer[-2];
{
+ receiver = stack_pointer[-2];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_Send(receiver, next_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(SEND);
#endif /* ENABLE_SPECIALIZATION */
}
// _SEND
- v = stack_pointer[-1];
{
+ v = stack_pointer[-1];
PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);
PyObject *retval_o;
assert(frame != &entry_frame);
DISPATCH_INLINED(gen_frame);
}
if (PyStackRef_Is(v, PyStackRef_None) && PyIter_Check(receiver_o)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
retval_o = Py_TYPE(receiver_o)->tp_iternext(receiver_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
retval_o = PyObject_CallMethodOneArg(receiver_o,
&_Py_ID(send),
PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
if (retval_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (matches) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_MonitorRaise(tstate, frame, this_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyGen_FetchStopIterationValue(&retval_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err == 0) {
assert(retval_o != NULL);
JUMPBY(oparg);
}
else {
- goto error;
+ PyStackRef_CLOSE(v);
+ if (true) goto pop_1_error;
}
}
PyStackRef_CLOSE(v);
DEOPT_IF(tstate->interp->eval_frame, SEND);
}
// _SEND_GEN_FRAME
- v = stack_pointer[-1];
- receiver = stack_pointer[-2];
{
+ v = stack_pointer[-1];
+ receiver = stack_pointer[-2];
PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(receiver);
DEOPT_IF(Py_TYPE(gen) != &PyGen_Type && Py_TYPE(gen) != &PyCoro_Type, SEND);
DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, SEND);
gen_frame->previous = frame;
}
// _PUSH_FRAME
- new_frame = gen_frame;
{
+ new_frame = gen_frame;
// Write it out explicitly because it's subtly different.
// Eventually this should be the only occurrence of this code.
assert(tstate->interp->eval_frame == NULL);
+ _PyInterpreterFrame *temp = new_frame;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(new_frame->previous == frame || new_frame->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
- frame = tstate->current_frame = new_frame;
+ frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
LOAD_SP();
LOAD_IP(0);
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(SETUP_ANNOTATIONS);
- int err;
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);
if (true) goto error;
}
/* check if __annotations__ in locals()... */
- if (PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict) < 0) goto error;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err < 0) goto error;
if (ann_dict == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
ann_dict = PyDict_New();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (ann_dict == NULL) goto error;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
ann_dict);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(ann_dict);
if (err) goto error;
}
_PyStackRef v;
v = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
if (err) goto pop_1_error;
stack_pointer += -1;
next_instr += 1;
INSTRUCTION_STATS(SET_FUNCTION_ATTRIBUTE);
_PyStackRef attr_st;
- _PyStackRef func_st;
- func_st = stack_pointer[-1];
+ _PyStackRef func_in;
+ _PyStackRef func_out;
+ func_in = stack_pointer[-1];
attr_st = stack_pointer[-2];
- PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
- PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st);
+ PyObject *func = PyStackRef_AsPyObjectBorrow(func_in);
+ PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st);
+ func_out = func_in;
assert(PyFunction_Check(func));
- PyFunctionObject *func_obj = (PyFunctionObject *)func;
- switch(oparg) {
- case MAKE_FUNCTION_CLOSURE:
- assert(func_obj->func_closure == NULL);
- func_obj->func_closure = attr;
- break;
- case MAKE_FUNCTION_ANNOTATIONS:
- assert(func_obj->func_annotations == NULL);
- func_obj->func_annotations = attr;
- break;
- case MAKE_FUNCTION_KWDEFAULTS:
- assert(PyDict_CheckExact(attr));
- assert(func_obj->func_kwdefaults == NULL);
- func_obj->func_kwdefaults = attr;
- break;
- case MAKE_FUNCTION_DEFAULTS:
- assert(PyTuple_CheckExact(attr));
- assert(func_obj->func_defaults == NULL);
- func_obj->func_defaults = attr;
- break;
- case MAKE_FUNCTION_ANNOTATE:
- assert(PyCallable_Check(attr));
- assert(func_obj->func_annotate == NULL);
- func_obj->func_annotate = attr;
- break;
- default:
- Py_UNREACHABLE();
- }
- stack_pointer[-2] = func_st;
+ size_t offset = _Py_FunctionAttributeOffsets[oparg];
+ assert(offset != 0);
+ PyObject **ptr = (PyObject **)(((char *)func) + offset);
+ assert(*ptr == NULL);
+ *ptr = attr;
+ stack_pointer[-2] = func_out;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
_PyStackRef iterable;
iterable = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(iterable));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
if (err < 0) goto pop_1_error;
stack_pointer += -1;
_PyStackRef owner;
_PyStackRef v;
// _SPECIALIZE_STORE_ATTR
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_StoreAttr(owner, next_instr, name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(STORE_ATTR);
}
/* Skip 3 cache entries */
// _STORE_ATTR
- v = stack_pointer[-2];
{
+ v = stack_pointer[-2];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner),
name, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(owner);
if (err) goto pop_2_error;
_PyStackRef value;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
DEOPT_IF(_PyObject_InlineValues(owner_o)->valid == 0, STORE_ATTR);
}
// _STORE_ATTR_INSTANCE_VALUE
- value = stack_pointer[-2];
{
+ value = stack_pointer[-2];
uint16_t offset = read_u16(&this_instr[4].cache);
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
STAT_INC(STORE_ATTR, hit);
_PyStackRef value;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
}
// _STORE_ATTR_SLOT
- value = stack_pointer[-2];
{
+ value = stack_pointer[-2];
uint16_t index = read_u16(&this_instr[4].cache);
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
char *addr = (char *)owner_o + index;
_PyStackRef value;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
}
// _STORE_ATTR_WITH_HINT
- value = stack_pointer[-2];
{
+ value = stack_pointer[-2];
uint16_t hint = read_u16(&this_instr[4].cache);
PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_MANAGED_DICT);
}
old_value = ep->me_value;
PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
ep->me_value = PyStackRef_AsPyObjectSteal(value);
// old_value should be DECREFed after GC track checking is done, if not, it could raise a segmentation fault,
// when dict only holds the strong reference to value in ep->me_value.
_PyStackRef v;
v = stack_pointer[-1];
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
_PyStackRef v;
v = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
if (err) goto pop_1_error;
stack_pointer += -1;
PyObject *ns = LOCALS();
int err;
if (ns == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when storing %R", name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
if (true) goto pop_1_error;
}
- if (PyDict_CheckExact(ns))
- err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- else
- err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
+ if (PyDict_CheckExact(ns)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ }
+ else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ }
PyStackRef_CLOSE(v);
if (err) goto pop_1_error;
stack_pointer += -1;
#endif /* ENABLE_SPECIALIZATION */
}
// _STORE_SLICE
- stop = stack_pointer[-1];
- start = stack_pointer[-2];
- container = stack_pointer[-3];
- v = stack_pointer[-4];
{
+ stop = stack_pointer[-1];
+ start = stack_pointer[-2];
+ container = stack_pointer[-3];
+ v = stack_pointer[-4];
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start),
PyStackRef_AsPyObjectSteal(stop));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
int err;
if (slice == NULL) {
err = 1;
}
else {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
Py_DECREF(slice);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(container);
_PyStackRef sub;
_PyStackRef v;
// _SPECIALIZE_STORE_SUBSCR
- sub = stack_pointer[-1];
- container = stack_pointer[-2];
{
+ sub = stack_pointer[-1];
+ container = stack_pointer[-2];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_StoreSubscr(container, sub, next_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(STORE_SUBSCR);
#endif /* ENABLE_SPECIALIZATION */
}
// _STORE_SUBSCR
- v = stack_pointer[-3];
{
+ v = stack_pointer[-3];
/* container[sub] = v */
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st);
DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR);
STAT_INC(STORE_SUBSCR, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = _PyDict_SetItem_Take2((PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(sub),
PyStackRef_AsPyObjectSteal(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(dict_st);
if (err) goto pop_3_error;
stack_pointer += -3;
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(SWAP);
- _PyStackRef bottom;
- _PyStackRef top;
- top = stack_pointer[-1];
- bottom = stack_pointer[-2 - (oparg-2)];
+ _PyStackRef bottom_in;
+ _PyStackRef top_in;
+ _PyStackRef top_out;
+ _PyStackRef bottom_out;
+ top_in = stack_pointer[-1];
+ bottom_in = stack_pointer[-2 - (oparg-2)];
+ bottom_out = bottom_in;
+ top_out = top_in;
assert(oparg >= 2);
- stack_pointer[-2 - (oparg-2)] = top;
- stack_pointer[-1] = bottom;
+ stack_pointer[-2 - (oparg-2)] = top_out;
+ stack_pointer[-1] = bottom_out;
DISPATCH();
}
_PyStackRef value;
_PyStackRef res;
// _SPECIALIZE_TO_BOOL
- value = stack_pointer[-1];
{
+ value = stack_pointer[-1];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_ToBool(value, next_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(TO_BOOL);
/* Skip 2 cache entries */
// _TO_BOOL
{
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
if (err < 0) goto pop_1_error;
res = err ? PyStackRef_True : PyStackRef_False;
_PyStackRef res;
/* Skip 1 cache entry */
// _GUARD_TYPE_VERSION
- owner = stack_pointer[-1];
{
+ owner = stack_pointer[-1];
uint32_t type_version = read_u32(&this_instr[2].cache);
PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner));
assert(type_version != 0);
DEOPT_IF(tp->tp_version_tag != type_version, TO_BOOL);
}
// _REPLACE_WITH_TRUE
- value = owner;
{
+ value = owner;
PyStackRef_CLOSE(value);
res = PyStackRef_True;
}
_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);
PyStackRef_CLOSE(value);
if (res_o == NULL) goto pop_1_error;
res = PyStackRef_FromPyObjectSteal(res_o);
_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);
PyStackRef_CLOSE(value);
if (res_o == NULL) goto pop_1_error;
res = PyStackRef_FromPyObjectSteal(res_o);
seq = stack_pointer[-1];
right = &stack_pointer[(oparg & 0xFF)];
_PyStackRef *top = right + (oparg >> 8);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(seq);
if (res == 0) goto pop_1_error;
stack_pointer += (oparg & 0xFF) + (oparg >> 8);
_PyStackRef seq;
_PyStackRef *output;
// _SPECIALIZE_UNPACK_SEQUENCE
- seq = stack_pointer[-1];
{
+ seq = stack_pointer[-1];
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
#if ENABLE_SPECIALIZATION
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_Py_Specialize_UnpackSequence(seq, next_instr, oparg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(UNPACK_SEQUENCE);
{
output = &stack_pointer[-1];
_PyStackRef *top = output + oparg;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(seq);
if (res == 0) goto pop_1_error;
}
DEOPT_IF(PyTuple_GET_SIZE(seq_o) != 2, UNPACK_SEQUENCE);
STAT_INC(UNPACK_SEQUENCE, hit);
val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0));
- stack_pointer[0] = val0;
val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1));
- stack_pointer[-1] = val1;
PyStackRef_CLOSE(seq);
+ stack_pointer[-1] = val1;
+ stack_pointer[0] = val0;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
(void)lasti; // Shut up compiler warning if asserts are off
PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb};
int has_self = !PyStackRef_IsNull(exit_self);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,
(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL));
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(res)) goto error;
stack_pointer[0] = res;
stack_pointer += 1;
assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1);
assert(oparg == 0 || oparg == 1);
gen->gi_frame_state = FRAME_SUSPENDED + oparg;
+ _PyStackRef temp = retval;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
assert(INLINE_CACHE_ENTRIES_SEND == INLINE_CACHE_ENTRIES_FOR_ITER);
#if TIER_ONE
assert(frame->instr_ptr->op.code == INSTRUMENTED_LINE ||
- frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT ||
- _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR);
+ frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT ||
+ _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR);
#endif
+ stack_pointer = _PyFrame_GetStackPointer(frame);
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
- LOAD_SP();
- value = retval;
+ value = temp;
LLTRACE_RESUME_FRAME();
stack_pointer[0] = value;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
-
- TARGET(_DO_CALL_FUNCTION_EX) {
- _Py_CODEUNIT *this_instr = frame->instr_ptr = next_instr;
- (void)this_instr;
- next_instr += 1;
- INSTRUCTION_STATS(_DO_CALL_FUNCTION_EX);
- _PyStackRef func_st;
- _PyStackRef callargs_st;
- _PyStackRef kwargs_st = PyStackRef_NULL;
- _PyStackRef result;
- if (oparg & 1) { kwargs_st = stack_pointer[-(oparg & 1)]; }
- callargs_st = stack_pointer[-1 - (oparg & 1)];
- func_st = stack_pointer[-3 - (oparg & 1)];
- PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
- PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st);
- PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st);
- // DICT_MERGE is called before this opcode if there are kwargs.
- // It converts all dict subtypes in kwargs into regular dicts.
- assert(kwargs == NULL || PyDict_CheckExact(kwargs));
- if (!PyTuple_CheckExact(callargs)) {
- int err = check_args_iterable(tstate, func, callargs);
- if (err < 0) {
- goto error;
- }
- PyObject *tuple = PySequence_Tuple(callargs);
- if (tuple == NULL) {
- goto error;
- }
- PyStackRef_CLOSE(callargs_st);
- callargs_st = PyStackRef_FromPyObjectSteal(tuple);
- callargs = tuple;
- }
- assert(PyTuple_CheckExact(callargs));
- EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func);
- if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) {
- PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ?
- PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;
- int err = _Py_call_instrumentation_2args(
- tstate, PY_MONITORING_EVENT_CALL,
- frame, this_instr, func, arg);
- if (err) goto error;
- result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs));
- if (!PyFunction_Check(func) && !PyMethod_Check(func)) {
- if (PyStackRef_IsNull(result)) {
- _Py_call_instrumentation_exc2(
- tstate, PY_MONITORING_EVENT_C_RAISE,
- frame, this_instr, func, arg);
- }
- else {
- int err = _Py_call_instrumentation_2args(
- tstate, PY_MONITORING_EVENT_C_RETURN,
- frame, this_instr, func, arg);
- if (err < 0) {
- PyStackRef_CLEAR(result);
- }
- }
- }
- }
- else {
- if (Py_TYPE(func) == &PyFunction_Type &&
- tstate->interp->eval_frame == NULL &&
- ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) {
- assert(PyTuple_CheckExact(callargs));
- Py_ssize_t nargs = PyTuple_GET_SIZE(callargs);
- int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags;
- PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func));
- _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
- tstate, func_st, locals,
- nargs, callargs, kwargs, frame);
- // Need to manually shrink the stack since we exit with DISPATCH_INLINED.
- STACK_SHRINK(oparg + 3);
- if (new_frame == NULL) {
- goto error;
- }
- assert(next_instr - this_instr == 1);
- frame->return_offset = 1;
- DISPATCH_INLINED(new_frame);
- }
- result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs));
- }
- PyStackRef_CLOSE(func_st);
- PyStackRef_CLOSE(callargs_st);
- PyStackRef_XCLOSE(kwargs_st);
- assert(PyStackRef_AsPyObjectBorrow(PEEK(2 + (oparg & 1))) == NULL);
- if (PyStackRef_IsNull(result)) {
- stack_pointer += -3 - (oparg & 1);
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
- stack_pointer[-3 - (oparg & 1)] = result;
- stack_pointer += -2 - (oparg & 1);
- assert(WITHIN_STACK_BOUNDS());
- DISPATCH();
- }
#undef TIER_ONE
&&TARGET_UNPACK_EX,
&&TARGET_UNPACK_SEQUENCE,
&&TARGET_YIELD_VALUE,
- &&TARGET__DO_CALL_FUNCTION_EX,
+ &&_unknown_opcode,
&&_unknown_opcode,
&&_unknown_opcode,
&&_unknown_opcode,
res = sym_new_type(ctx, &PyFloat_Type);
}
}
- res = sym_new_unknown(ctx);
+ else {
+ res = sym_new_unknown(ctx);
+ }
}
op(_BINARY_OP_ADD_INT, (left, right -- res)) {
top = bottom;
}
- op(_SWAP, (bottom, unused[oparg-2], top --
- top, unused[oparg-2], bottom)) {
+ op(_SWAP, (bottom_in, unused[oparg-2], top_in --
+ top_out, unused[oparg-2], bottom_out)) {
+ bottom_out = bottom_in;
+ top_out = top_in;
}
op(_LOAD_ATTR_INSTANCE_VALUE, (offset/1, owner -- attr, null if (oparg & 1))) {
op(_LOAD_ATTR, (owner -- attr, self_or_null if (oparg & 1))) {
(void)owner;
attr = sym_new_not_null(ctx);
- if (oparg & 1) {
- self_or_null = sym_new_unknown(ctx);
- }
+ self_or_null = sym_new_unknown(ctx);
}
op(_LOAD_ATTR_MODULE, (index/1, owner -- attr, null if (oparg & 1))) {
op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null, args[oparg] -- new_frame: _Py_UOpsAbstractFrame *)) {
int argcount = oparg;
-
(void)callable;
PyCodeObject *co = NULL;
}
op(_RETURN_VALUE, (retval -- res)) {
- SYNC_SP();
+ SAVE_STACK();
ctx->frame->stack_pointer = stack_pointer;
frame_pop(ctx);
stack_pointer = ctx->frame->stack_pointer;
- res = retval;
/* Stack space handling */
assert(corresponding_check_stack == NULL);
// might be impossible, but bailing is still safe
ctx->done = true;
}
+ RELOAD_STACK();
+ res = retval;
}
op(_RETURN_GENERATOR, ( -- res)) {
}
case _END_SEND: {
- _Py_UopsSymbol *value;
- value = sym_new_not_null(ctx);
- stack_pointer[-2] = value;
+ _Py_UopsSymbol *val;
+ val = sym_new_not_null(ctx);
+ stack_pointer[-2] = val;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
ctx->frame->stack_pointer = stack_pointer;
frame_pop(ctx);
stack_pointer = ctx->frame->stack_pointer;
- res = retval;
/* Stack space handling */
assert(corresponding_check_stack == NULL);
assert(co != NULL);
// might be impossible, but bailing is still safe
ctx->done = true;
}
+ res = retval;
stack_pointer[0] = res;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_Py_UopsSymbol **res;
_Py_UopsSymbol *null = NULL;
res = &stack_pointer[0];
- for (int _i = 1; --_i >= 0;) {
- res[_i] = sym_new_not_null(ctx);
- }
+ res[0] = sym_new_not_null(ctx);
null = sym_new_null(ctx);
if (oparg & 1) stack_pointer[1] = null;
stack_pointer += 1 + (oparg & 1);
owner = stack_pointer[-1];
(void)owner;
attr = sym_new_not_null(ctx);
- if (oparg & 1) {
- self_or_null = sym_new_unknown(ctx);
- }
+ self_or_null = sym_new_unknown(ctx);
stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = self_or_null;
stack_pointer += (oparg & 1);
PyModuleObject *mod = (PyModuleObject *)sym_get_const(owner);
assert(PyModule_CheckExact(mod));
PyObject *dict = mod->md_dict;
+ stack_pointer[-1] = attr;
+ if (oparg & 1) stack_pointer[0] = null;
+ stack_pointer += (oparg & 1);
+ assert(WITHIN_STACK_BOUNDS());
PyObject *res = convert_global_to_const(this_instr, dict);
if (res != NULL) {
this_instr[-1].opcode = _POP_TOP;
attr = sym_new_const(ctx, res);
}
+ stack_pointer += -(oparg & 1);
+ assert(WITHIN_STACK_BOUNDS());
}
if (attr == NULL) {
/* No conversion made. We don't know what `attr` is. */
res = sym_new_type(ctx, &PyBool_Type);
}
else {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
res = _Py_uop_sym_new_not_null(ctx);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
stack_pointer[-2] = res;
stack_pointer += -1;
/* _MONITOR_CALL is not a viable micro-op for tier 2 */
case _PY_FRAME_GENERAL: {
- _Py_UopsSymbol **args;
_Py_UopsSymbol *self_or_null;
_Py_UopsSymbol *callable;
_Py_UOpsAbstractFrame *new_frame;
self_or_null = stack_pointer[-1 - oparg];
callable = stack_pointer[-2 - oparg];
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
(void)(self_or_null);
(void)(callable);
PyCodeObject *co = NULL;
break;
}
new_frame = frame_new(ctx, co, 0, NULL, 0);
- stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = (_Py_UopsSymbol *)new_frame;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
}
case _EXPAND_METHOD: {
- _Py_UopsSymbol *method;
+ _Py_UopsSymbol **method;
_Py_UopsSymbol **self;
+ method = &stack_pointer[-2 - oparg];
self = &stack_pointer[-1 - oparg];
- method = sym_new_not_null(ctx);
- for (int _i = 1; --_i >= 0;) {
- self[_i] = sym_new_not_null(ctx);
- }
- stack_pointer[-2 - oparg] = method;
+ method[0] = sym_new_not_null(ctx);
+ self[0] = sym_new_not_null(ctx);
break;
}
(void)callable;
PyCodeObject *co = NULL;
assert((this_instr + 2)->opcode == _PUSH_FRAME);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
co = get_code_with_logging((this_instr + 2));
if (co == NULL) {
ctx->done = true;
} else {
new_frame = frame_new(ctx, co, 0, NULL, 0);
}
- stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = (_Py_UopsSymbol *)new_frame;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
if (first_valid_check_stack == NULL) {
first_valid_check_stack = corresponding_check_stack;
}
- else if (corresponding_check_stack) {
- // delete all but the first valid _CHECK_STACK_SPACE
- corresponding_check_stack->opcode = _NOP;
+ else {
+ if (corresponding_check_stack) {
+ // delete all but the first valid _CHECK_STACK_SPACE
+ corresponding_check_stack->opcode = _NOP;
+ }
}
corresponding_check_stack = NULL;
break;
/* _INSTRUMENTED_CALL_KW is not a viable micro-op for tier 2 */
+ case _MAYBE_EXPAND_METHOD_KW: {
+ _Py_UopsSymbol **func;
+ _Py_UopsSymbol **maybe_self;
+ _Py_UopsSymbol **args;
+ _Py_UopsSymbol *kwnames_out;
+ func = &stack_pointer[-3 - oparg];
+ maybe_self = &stack_pointer[-2 - oparg];
+ args = &stack_pointer[-1 - oparg];
+ func[0] = sym_new_not_null(ctx);
+ maybe_self[0] = sym_new_not_null(ctx);
+ for (int _i = oparg; --_i >= 0;) {
+ args[_i] = sym_new_not_null(ctx);
+ }
+ kwnames_out = sym_new_not_null(ctx);
+ stack_pointer[-1] = kwnames_out;
+ break;
+ }
+
/* _DO_CALL_KW is not a viable micro-op for tier 2 */
case _PY_FRAME_KW: {
}
case _EXPAND_METHOD_KW: {
- _Py_UopsSymbol *method;
+ _Py_UopsSymbol **method;
_Py_UopsSymbol **self;
- _Py_UopsSymbol *kwnames;
+ method = &stack_pointer[-3 - oparg];
self = &stack_pointer[-2 - oparg];
- method = sym_new_not_null(ctx);
- for (int _i = 1; --_i >= 0;) {
- self[_i] = sym_new_not_null(ctx);
- }
- kwnames = sym_new_not_null(ctx);
- stack_pointer[-3 - oparg] = method;
- stack_pointer[-1] = kwnames;
+ method[0] = sym_new_not_null(ctx);
+ self[0] = sym_new_not_null(ctx);
break;
}
/* _INSTRUMENTED_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */
- /* __DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */
+ case _MAKE_CALLARGS_A_TUPLE: {
+ _Py_UopsSymbol *tuple;
+ _Py_UopsSymbol *kwargs_out = NULL;
+ tuple = sym_new_not_null(ctx);
+ kwargs_out = sym_new_not_null(ctx);
+ stack_pointer[-1 - (oparg & 1)] = tuple;
+ if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_out;
+ break;
+ }
+
+ /* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */
case _MAKE_FUNCTION: {
_Py_UopsSymbol *func;
}
case _SET_FUNCTION_ATTRIBUTE: {
- _Py_UopsSymbol *func_st;
- func_st = sym_new_not_null(ctx);
- stack_pointer[-2] = func_st;
+ _Py_UopsSymbol *func_out;
+ func_out = sym_new_not_null(ctx);
+ stack_pointer[-2] = func_out;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
assert(framesize > 0);
assert(framesize <= curr_space);
curr_space -= framesize;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
co = get_code(this_instr);
if (co == NULL) {
// might be impossible, but bailing is still safe
ctx->done = true;
}
- stack_pointer[0] = res;
- stack_pointer += 1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
res = sym_new_type(ctx, &PyFloat_Type);
}
}
- res = sym_new_unknown(ctx);
+ else {
+ res = sym_new_unknown(ctx);
+ }
stack_pointer[-2] = res;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
case _SWAP: {
- _Py_UopsSymbol *top;
- _Py_UopsSymbol *bottom;
- top = stack_pointer[-1];
- bottom = stack_pointer[-2 - (oparg-2)];
- stack_pointer[-2 - (oparg-2)] = top;
- stack_pointer[-1] = bottom;
+ _Py_UopsSymbol *top_in;
+ _Py_UopsSymbol *bottom_in;
+ _Py_UopsSymbol *top_out;
+ _Py_UopsSymbol *bottom_out;
+ top_in = stack_pointer[-1];
+ bottom_in = stack_pointer[-2 - (oparg-2)];
+ bottom_out = bottom_in;
+ top_out = top_in;
+ stack_pointer[-2 - (oparg-2)] = top_out;
+ stack_pointer[-1] = bottom_out;
break;
}
if (sym_is_const(flag)) {
PyObject *value = sym_get_const(flag);
assert(value != NULL);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
eliminate_pop_guard(this_instr, value != Py_True);
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
if (sym_is_const(flag)) {
PyObject *value = sym_get_const(flag);
assert(value != NULL);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
eliminate_pop_guard(this_instr, value != Py_False);
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
if (sym_is_const(flag)) {
PyObject *value = sym_get_const(flag);
assert(value != NULL);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
eliminate_pop_guard(this_instr, !Py_IsNone(value));
}
- else if (sym_has_type(flag)) {
- assert(!sym_matches_type(flag, &_PyNone_Type));
- eliminate_pop_guard(this_instr, true);
+ else {
+ if (sym_has_type(flag)) {
+ assert(!sym_matches_type(flag, &_PyNone_Type));
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ eliminate_pop_guard(this_instr, true);
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
+ }
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
if (sym_is_const(flag)) {
PyObject *value = sym_get_const(flag);
assert(value != NULL);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
eliminate_pop_guard(this_instr, Py_IsNone(value));
}
- else if (sym_has_type(flag)) {
- assert(!sym_matches_type(flag, &_PyNone_Type));
- eliminate_pop_guard(this_instr, false);
+ else {
+ if (sym_has_type(flag)) {
+ assert(!sym_matches_type(flag, &_PyNone_Type));
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ eliminate_pop_guard(this_instr, false);
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
+ }
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+import itertools
import lexer
import parser
import re
from typing import Optional
-
@dataclass
class Properties:
- escapes: bool
+ escaping_calls: dict[lexer.Token, tuple[lexer.Token, lexer.Token]]
error_with_pop: bool
error_without_pop: bool
deopts: bool
needs_prev: bool = False
def dump(self, indent: str) -> None:
- print(indent, end="")
- text = ", ".join([f"{key}: {value}" for (key, value) in self.__dict__.items()])
+ simple_properties = self.__dict__.copy()
+ del simple_properties["escaping_calls"]
+ text = "escaping_calls:\n"
+ for tkns in self.escaping_calls.values():
+ text += f"{indent} {tkns}\n"
+ text += ", ".join([f"{key}: {value}" for (key, value) in simple_properties.items()])
print(indent, text, sep="")
@staticmethod
def from_list(properties: list["Properties"]) -> "Properties":
+ escaping_calls: dict[lexer.Token, tuple[lexer.Token, lexer.Token]] = {}
+ for p in properties:
+ escaping_calls.update(p.escaping_calls)
return Properties(
- escapes=any(p.escapes for p in properties),
+ escaping_calls=escaping_calls,
error_with_pop=any(p.error_with_pop for p in properties),
error_without_pop=any(p.error_without_pop for p in properties),
deopts=any(p.deopts for p in properties),
def infallible(self) -> bool:
return not self.error_with_pop and not self.error_without_pop
+ @property
+ def escapes(self) -> bool:
+ return bool(self.escaping_calls)
SKIP_PROPERTIES = Properties(
- escapes=False,
+ escaping_calls={},
error_with_pop=False,
error_without_pop=False,
deopts=False,
stack: StackEffect
caches: list[CacheEntry]
deferred_refs: dict[lexer.Token, str | None]
+ output_stores: list[lexer.Token]
body: list[lexer.Token]
properties: Properties
_size: int = -1
]
# Mark variables with matching names at the base of the stack as "peek"
modified = False
- for input, output in zip(inputs, outputs):
- if input.name == output.name and not modified:
- input.peek = output.peek = True
+ input_names: dict[str, lexer.Token] = { i.name : i.first_token for i in op.inputs if i.name != "unused" }
+ for input, output in itertools.zip_longest(inputs, outputs):
+ if output is None:
+ pass
+ elif input is None:
+ if output.name in input_names:
+ raise analysis_error(
+ f"Reuse of variable '{output.name}' at different stack location",
+ input_names[output.name])
+ elif input.name == output.name:
+ if not modified:
+ input.peek = output.peek = True
else:
modified = True
+ if output.name in input_names:
+ raise analysis_error(
+ f"Reuse of variable '{output.name}' at different stack location",
+ input_names[output.name])
if isinstance(op, parser.InstDef):
output_names = [out.name for out in outputs]
for input in inputs:
return [CacheEntry(i.name, int(i.size)) for i in caches]
+def find_assignment_target(node: parser.InstDef, idx: int) -> list[lexer.Token]:
+ """Find the tokens that make up the left-hand side of an assignment"""
+ offset = 0
+ for tkn in reversed(node.block.tokens[: idx]):
+ if tkn.kind in {"SEMI", "LBRACE", "RBRACE"}:
+ return node.block.tokens[idx - offset : idx]
+ offset += 1
+ return []
+
+
+def find_stores_outputs(node: parser.InstDef) -> list[lexer.Token]:
+ res: list[lexer.Token] = []
+ outnames = { out.name for out in node.outputs }
+ innames = { out.name for out in node.inputs }
+ for idx, tkn in enumerate(node.block.tokens):
+ if tkn.kind == "AND":
+ name = node.block.tokens[idx+1]
+ if name.text in outnames:
+ res.append(name)
+ if tkn.kind != "EQUALS":
+ continue
+ lhs = find_assignment_target(node, idx)
+ assert lhs
+ while lhs and lhs[0].kind == "COMMENT":
+ lhs = lhs[1:]
+ if len(lhs) != 1 or lhs[0].kind != "IDENTIFIER":
+ continue
+ name = lhs[0]
+ if name.text in innames:
+ raise analysis_error(f"Cannot assign to input variable '{name.text}'", name)
+ if name.text in outnames:
+ res.append(name)
+ return res
+
def analyze_deferred_refs(node: parser.InstDef) -> dict[lexer.Token, str | None]:
"""Look for PyStackRef_FromPyObjectNew() calls"""
- def find_assignment_target(idx: int) -> list[lexer.Token]:
- """Find the tokens that make up the left-hand side of an assignment"""
- offset = 1
- for tkn in reversed(node.block.tokens[: idx - 1]):
- if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE":
- return node.block.tokens[idx - offset : idx - 1]
- offset += 1
- return []
-
def in_frame_push(idx: int) -> bool:
for tkn in reversed(node.block.tokens[: idx - 1]):
- if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE":
+ if tkn.kind in {"SEMI", "LBRACE", "RBRACE"}:
return False
if tkn.kind == "IDENTIFIER" and tkn.text == "_PyFrame_PushUnchecked":
return True
continue
raise analysis_error("Expected '=' before PyStackRef_FromPyObjectNew", tkn)
- lhs = find_assignment_target(idx)
+ lhs = find_assignment_target(node, idx - 1)
if len(lhs) == 0:
raise analysis_error(
"PyStackRef_FromPyObjectNew() must be assigned to an output", tkn
)
name = lhs[0].text
- if not any(var.name == name for var in node.outputs):
+ match = (
+ any(var.name == name for var in node.inputs)
+ or any(var.name == name for var in node.outputs)
+ )
+ if not match:
raise analysis_error(
- f"PyStackRef_FromPyObjectNew() must be assigned to an output, not '{name}'",
+ f"PyStackRef_FromPyObjectNew() must be assigned to an input or output, not '{name}'",
tkn,
)
NON_ESCAPING_FUNCTIONS = (
- "PyStackRef_FromPyObjectSteal",
+ "PyCFunction_GET_FLAGS",
+ "PyCFunction_GET_FUNCTION",
+ "PyCFunction_GET_SELF",
+ "PyCell_GetRef",
+ "PyCell_New",
+ "PyCell_SwapTakeRef",
+ "PyExceptionInstance_Class",
+ "PyException_GetCause",
+ "PyException_GetContext",
+ "PyException_GetTraceback",
+ "PyFloat_AS_DOUBLE",
+ "PyFloat_FromDouble",
+ "PyFunction_GET_CODE",
+ "PyFunction_GET_GLOBALS",
+ "PyList_GET_ITEM",
+ "PyList_GET_SIZE",
+ "PyList_SET_ITEM",
+ "PyLong_AsLong",
+ "PyLong_FromLong",
+ "PyLong_FromSsize_t",
+ "PySlice_New",
"PyStackRef_AsPyObjectBorrow",
+ "PyStackRef_AsPyObjectNew",
"PyStackRef_AsPyObjectSteal",
+ "PyStackRef_CLEAR",
"PyStackRef_CLOSE",
"PyStackRef_DUP",
- "PyStackRef_CLEAR",
+ "PyStackRef_False",
+ "PyStackRef_FromPyObjectImmortal",
+ "PyStackRef_FromPyObjectNew",
+ "PyStackRef_FromPyObjectSteal",
+ "PyStackRef_Is",
"PyStackRef_IsNull",
+ "PyStackRef_None",
"PyStackRef_TYPE",
- "PyStackRef_False",
"PyStackRef_True",
- "PyStackRef_None",
- "PyStackRef_Is",
- "PyStackRef_FromPyObjectNew",
- "PyStackRef_AsPyObjectNew",
- "PyStackRef_FromPyObjectImmortal",
- "Py_INCREF",
- "_PyManagedDictPointer_IsValues",
- "_PyObject_GetManagedDict",
- "_PyObject_ManagedDictPointer",
- "_PyObject_InlineValues",
- "_PyDictValues_AddToInsertionOrder",
- "Py_DECREF",
- "Py_XDECREF",
- "_Py_DECREF_SPECIALIZED",
- "DECREF_INPUTS_AND_REUSE_FLOAT",
- "PyUnicode_Append",
- "_PyLong_IsZero",
- "Py_SIZE",
- "Py_TYPE",
- "PyList_GET_ITEM",
- "PyList_SET_ITEM",
"PyTuple_GET_ITEM",
- "PyList_GET_SIZE",
"PyTuple_GET_SIZE",
+ "PyType_HasFeature",
+ "PyUnicode_Append",
+ "PyUnicode_Concat",
+ "PyUnicode_GET_LENGTH",
+ "PyUnicode_READ_CHAR",
"Py_ARRAY_LENGTH",
+ "Py_CLEAR",
+ "Py_DECREF",
+ "Py_FatalError",
+ "Py_INCREF",
+ "Py_IS_TYPE",
+ "Py_NewRef",
+ "Py_REFCNT",
+ "Py_SIZE",
+ "Py_TYPE",
+ "Py_UNREACHABLE",
"Py_Unicode_GET_LENGTH",
- "PyUnicode_READ_CHAR",
- "_Py_SINGLETON",
- "PyUnicode_GET_LENGTH",
- "_PyLong_IsCompact",
- "_PyLong_IsNonNegativeCompact",
+ "Py_XDECREF",
+ "_PyCode_CODE",
+ "_PyDictValues_AddToInsertionOrder",
+ "_PyErr_Occurred",
+ "_PyEval_FrameClearAndPop",
+ "_PyFrame_GetCode",
+ "_PyFrame_IsIncomplete",
+ "_PyFrame_PushUnchecked",
+ "_PyFrame_SetStackPointer",
+ "_PyFrame_StackPush",
+ "_PyFunction_SetVersion",
+ "_PyGen_GetGeneratorFromFrame",
+ "_PyInterpreterState_GET",
+ "_PyList_AppendTakeRef",
+ "_PyList_FromStackRefSteal",
+ "_PyList_ITEMS",
+ "_PyLong_Add",
"_PyLong_CompactValue",
"_PyLong_DigitCount",
- "_Py_NewRef",
- "_Py_IsImmortal",
- "PyLong_FromLong",
- "_Py_STR",
- "_PyLong_Add",
+ "_PyLong_IsCompact",
+ "_PyLong_IsNonNegativeCompact",
+ "_PyLong_IsZero",
"_PyLong_Multiply",
"_PyLong_Subtract",
- "Py_NewRef",
- "_PyList_ITEMS",
- "_PyTuple_ITEMS",
- "_PyList_AppendTakeRef",
- "_Py_atomic_load_uintptr_relaxed",
- "_PyFrame_GetCode",
+ "_PyManagedDictPointer_IsValues",
+ "_PyObject_GC_IS_TRACKED",
+ "_PyObject_GC_MAY_BE_TRACKED",
+ "_PyObject_GC_TRACK",
+ "_PyObject_GetManagedDict",
+ "_PyObject_InlineValues",
+ "_PyObject_ManagedDictPointer",
"_PyThreadState_HasStackSpace",
- "_PyUnicode_Equal",
- "_PyFrame_SetStackPointer",
+ "_PyTuple_FromArraySteal",
+ "_PyTuple_FromStackRefSteal",
+ "_PyTuple_ITEMS",
"_PyType_HasFeature",
- "PyUnicode_Concat",
- "PySlice_New",
+ "_PyType_NewManagedObject",
+ "_PyUnicode_Equal",
+ "_PyUnicode_JoinArray",
+ "_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY",
+ "_Py_DECREF_NO_DEALLOC",
+ "_Py_DECREF_SPECIALIZED",
+ "_Py_EnterRecursiveCallTstateUnchecked",
+ "_Py_ID",
+ "_Py_IsImmortal",
+ "_Py_IsImmortalLoose",
"_Py_LeaveRecursiveCallPy",
- "CALL_STAT_INC",
- "STAT_INC",
+ "_Py_LeaveRecursiveCallTstate",
+ "_Py_NewRef",
+ "_Py_SINGLETON",
+ "_Py_STR",
+ "_Py_atomic_load_uintptr_relaxed",
+ "_Py_set_eval_breaker_bit",
+ "advance_backoff_counter",
+ "assert",
+ "backoff_counter_triggers",
+ "initial_temperature_backoff_counter",
"maybe_lltrace_resume_frame",
- "_PyUnicode_JoinArray",
- "_PyEval_FrameClearAndPop",
- "_PyFrame_StackPush",
- "PyCell_New",
- "PyFloat_AS_DOUBLE",
- "_PyFrame_PushUnchecked",
- "Py_FatalError",
- "STACKREFS_TO_PYOBJECTS",
- "STACKREFS_TO_PYOBJECTS_CLEANUP",
- "CONVERSION_FAILED",
- "_PyList_FromStackRefSteal",
- "_PyTuple_FromArraySteal",
- "_PyTuple_FromStackRefSteal",
- "_Py_set_eval_breaker_bit"
+ "restart_backoff_counter",
)
-ESCAPING_FUNCTIONS = (
- "import_name",
- "import_from",
-)
-
-
-def makes_escaping_api_call(instr: parser.InstDef) -> bool:
- if "CALL_INTRINSIC" in instr.name:
- return True
- if instr.name == "_BINARY_OP":
- return True
- tkns = iter(instr.tokens)
- for tkn in tkns:
- if tkn.kind != lexer.IDENTIFIER:
- continue
+def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token:
+ assert idx < len(node.block.tokens)
+ while True:
+ tkn = node.block.tokens[idx-1]
+ if tkn.kind in {"SEMI", "LBRACE", "RBRACE"}:
+ break
+ idx -= 1
+ assert idx > 0
+ while node.block.tokens[idx].kind == "COMMENT":
+ idx += 1
+ return node.block.tokens[idx]
+
+
+def find_stmt_end(node: parser.InstDef, idx: int) -> lexer.Token:
+ assert idx < len(node.block.tokens)
+ while True:
+ idx += 1
+ tkn = node.block.tokens[idx]
+ if tkn.kind == "SEMI":
+ return node.block.tokens[idx+1]
+
+def check_escaping_calls(instr: parser.InstDef, escapes: dict[lexer.Token, tuple[lexer.Token, lexer.Token]]) -> None:
+ calls = {escapes[t][0] for t in escapes}
+ in_if = 0
+ tkn_iter = iter(instr.block.tokens)
+ for tkn in tkn_iter:
+ if tkn.kind == "IF":
+ next(tkn_iter)
+ in_if = 1
+ if tkn.kind == "IDENTIFIER" and tkn.text in ("DEOPT_IF", "ERROR_IF"):
+ next(tkn_iter)
+ in_if = 1
+ elif tkn.kind == "LPAREN" and in_if:
+ in_if += 1
+ elif tkn.kind == "RPAREN":
+ if in_if:
+ in_if -= 1
+ elif tkn in calls and in_if:
+ raise analysis_error(f"Escaping call '{tkn.text} in condition", tkn)
+
+def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, tuple[lexer.Token, lexer.Token]]:
+ result: dict[lexer.Token, tuple[lexer.Token, lexer.Token]] = {}
+ tokens = instr.block.tokens
+ for idx, tkn in enumerate(tokens):
try:
- next_tkn = next(tkns)
- except StopIteration:
- return False
+ next_tkn = tokens[idx+1]
+ except IndexError:
+ break
+ if tkn.kind == "SWITCH":
+ raise analysis_error(f"switch statements are not supported due to their complex flow control. Sorry.", tkn)
if next_tkn.kind != lexer.LPAREN:
continue
- if tkn.text in ESCAPING_FUNCTIONS:
- return True
- if tkn.text == "tp_vectorcall":
- return True
- if not tkn.text.startswith("Py") and not tkn.text.startswith("_Py"):
- continue
- if tkn.text.endswith("Check"):
- continue
- if tkn.text.startswith("Py_Is"):
- continue
- if tkn.text.endswith("CheckExact"):
- continue
- if tkn.text in NON_ESCAPING_FUNCTIONS:
+ if tkn.kind == lexer.IDENTIFIER:
+ if tkn.text.upper() == tkn.text:
+ # simple macro
+ continue
+ #if not tkn.text.startswith(("Py", "_Py", "monitor")):
+ # continue
+ if tkn.text.startswith(("sym_", "optimize_")):
+ # Optimize functions
+ continue
+ if tkn.text.endswith("Check"):
+ continue
+ if tkn.text.startswith("Py_Is"):
+ continue
+ if tkn.text.endswith("CheckExact"):
+ continue
+ if tkn.text in NON_ESCAPING_FUNCTIONS:
+ continue
+ elif tkn.kind == "RPAREN":
+ prev = tokens[idx-1]
+ if prev.text.endswith("_t") or prev.text == "*" or prev.text == "int":
+ #cast
+ continue
+ elif tkn.kind != "RBRACKET":
continue
- return True
- return False
+ start = find_stmt_start(instr, idx)
+ end = find_stmt_end(instr, idx)
+ result[start] = tkn, end
+ check_escaping_calls(instr, result)
+ return result
EXITS = {
def compute_properties(op: parser.InstDef) -> Properties:
+ escaping_calls = find_escaping_api_calls(op)
has_free = (
variable_used(op, "PyCell_New")
or variable_used(op, "PyCell_GetRef")
error_with_pop = has_error_with_pop(op)
error_without_pop = has_error_without_pop(op)
return Properties(
- escapes=makes_escaping_api_call(op),
+ escaping_calls=escaping_calls,
error_with_pop=error_with_pop,
error_without_pop=error_without_pop,
deopts=deopts_if,
stack=analyze_stack(op),
caches=analyze_caches(inputs),
deferred_refs=analyze_deferred_refs(op),
+ output_stores=find_stores_outputs(op),
body=op.block.tokens,
properties=compute_properties(op),
)
stack=analyze_stack(op, bit),
caches=analyze_caches(inputs),
deferred_refs=analyze_deferred_refs(op),
+ output_stores=find_stores_outputs(op),
body=op.block.tokens,
properties=properties,
)
stack=analyze_stack(op),
caches=analyze_caches(inputs),
deferred_refs=analyze_deferred_refs(op),
+ output_stores=find_stores_outputs(op),
body=op.block.tokens,
properties=properties,
)
def set_position(self, tkn: Token) -> None:
if self.last_token is not None:
- if self.last_token.line < tkn.line:
+ if self.last_token.end_line < tkn.line:
self.out.write("\n")
+ if self.last_token.line < tkn.line:
if self.line_directives:
self.out.write(f'#line {tkn.line} "{tkn.filename}"\n')
self.out.write(" " * self.indents[-1])
self.maybe_dedent(tkn.text)
self.set_position(tkn)
self.emit_text(tkn.text)
+ if tkn.kind == "CMACRO":
+ self.newline = True
self.maybe_indent(tkn.text)
def emit_str(self, txt: str) -> None:
analysis_error,
)
from cwriter import CWriter
-from typing import Callable, Mapping, TextIO, Iterator
+from typing import Callable, Mapping, TextIO, Iterator, Iterable
from lexer import Token
-from stack import Stack
+from stack import Stack, Local, Storage, StackError
+# Set this to true for voluminous output showing state of stack and locals
+PRINT_STACKS = False
+
+class TokenIterator:
+
+ look_ahead: Token | None
+ iterator: Iterator[Token]
+
+ def __init__(self, tkns: Iterable[Token]):
+ self.iterator = iter(tkns)
+ self.look_ahead = None
+
+ def __iter__(self) -> "TokenIterator":
+ return self
+
+ def __next__(self) -> Token:
+ if self.look_ahead is None:
+ return next(self.iterator)
+ else:
+ res = self.look_ahead
+ self.look_ahead = None
+ return res
+
+ def peek(self) -> Token | None:
+ if self.look_ahead is None:
+ for tkn in self.iterator:
+ self.look_ahead = tkn
+ break
+ return self.look_ahead
ROOT = Path(__file__).parent.parent.parent
DEFAULT_INPUT = (ROOT / "Python/bytecodes.c").absolute().as_posix()
)
-def emit_to(out: CWriter, tkn_iter: Iterator[Token], end: str) -> None:
+def emit_to(out: CWriter, tkn_iter: TokenIterator, end: str) -> Token:
parens = 0
for tkn in tkn_iter:
if tkn.kind == end and parens == 0:
- return
+ return tkn
if tkn.kind == "LPAREN":
parens += 1
if tkn.kind == "RPAREN":
parens -= 1
out.emit(tkn)
+ raise analysis_error(f"Expecting {end}. Reached end of file", tkn)
ReplacementFunctionType = Callable[
- [Token, Iterator[Token], Uop, Stack, Instruction | None], None
+ [Token, TokenIterator, Uop, Storage, Instruction | None], bool
]
+def always_true(tkn: Token | None) -> bool:
+ if tkn is None:
+ return False
+ return tkn.text in {"true", "1"}
+
class Emitter:
out: CWriter
"ERROR_IF": self.error_if,
"ERROR_NO_POP": self.error_no_pop,
"DECREF_INPUTS": self.decref_inputs,
+ "DEAD": self.kill,
+ "INPUTS_DEAD": self.kill_inputs,
"SYNC_SP": self.sync_sp,
- "PyStackRef_FromPyObjectNew": self.py_stack_ref_from_py_object_new,
+ "SAVE_STACK": self.save_stack,
+ "RELOAD_STACK": self.reload_stack,
+ "PyStackRef_CLOSE": self.stackref_close,
+ "PyStackRef_AsPyObjectSteal": self.stackref_steal,
+ "DISPATCH": self.dispatch
}
self.out = out
+ def dispatch(
+ self,
+ tkn: Token,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> bool:
+ self.emit(tkn)
+ return False
+
def deopt_if(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- unused: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
self.out.emit_at("DEOPT_IF", tkn)
- self.out.emit(next(tkn_iter))
+ lparen = next(tkn_iter)
+ self.emit(lparen)
+ assert lparen.kind == "LPAREN"
+ first_tkn = tkn_iter.peek()
emit_to(self.out, tkn_iter, "RPAREN")
next(tkn_iter) # Semi colon
self.out.emit(", ")
assert inst.family is not None
self.out.emit(inst.family.name)
self.out.emit(");\n")
+ return not always_true(first_tkn)
exit_if = deopt_if
def error_if(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- stack: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
self.out.emit_at("if ", tkn)
- self.out.emit(next(tkn_iter))
+ lparen = next(tkn_iter)
+ self.emit(lparen)
+ assert lparen.kind == "LPAREN"
+ first_tkn = tkn_iter.peek()
emit_to(self.out, tkn_iter, "COMMA")
label = next(tkn_iter).text
next(tkn_iter) # RPAREN
next(tkn_iter) # Semi colon
self.out.emit(") ")
- c_offset = stack.peek_offset()
+ storage.clear_inputs("at ERROR_IF")
+ c_offset = storage.stack.peek_offset()
try:
offset = -int(c_offset)
except ValueError:
self.out.emit(";\n")
else:
self.out.emit("{\n")
- stack.flush_locally(self.out)
+ storage.copy().flush(self.out)
self.out.emit("goto ")
self.out.emit(label)
self.out.emit(";\n")
self.out.emit("}\n")
+ return not always_true(first_tkn)
def error_no_pop(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- stack: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
next(tkn_iter) # LPAREN
next(tkn_iter) # RPAREN
next(tkn_iter) # Semi colon
self.out.emit_at("goto error;", tkn)
+ return False
def decref_inputs(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- stack: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
next(tkn_iter)
next(tkn_iter)
next(tkn_iter)
self.out.emit(f"PyStackRef_XCLOSE({var.name});\n")
else:
self.out.emit(f"PyStackRef_CLOSE({var.name});\n")
+ for input in storage.inputs:
+ input.defined = False
+ return True
+
+ def kill_inputs(
+ self,
+ tkn: Token,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> bool:
+ next(tkn_iter)
+ next(tkn_iter)
+ next(tkn_iter)
+ for var in storage.inputs:
+ var.defined = False
+ return True
+
+ def kill(
+ self,
+ tkn: Token,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> bool:
+ next(tkn_iter)
+ name_tkn = next(tkn_iter)
+ name = name_tkn.text
+ next(tkn_iter)
+ next(tkn_iter)
+ for var in storage.inputs:
+ if var.name == name:
+ var.defined = False
+ break
+ else:
+ raise analysis_error(f"'{name}' is not a live input-only variable", name_tkn)
+ return True
+
+ def stackref_close(
+ self,
+ tkn: Token,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> bool:
+ self.out.emit(tkn)
+ tkn = next(tkn_iter)
+ assert tkn.kind == "LPAREN"
+ self.out.emit(tkn)
+ name = next(tkn_iter)
+ self.out.emit(name)
+ if name.kind == "IDENTIFIER":
+ for var in storage.inputs:
+ if var.name == name.text:
+ var.defined = False
+ rparen = emit_to(self.out, tkn_iter, "RPAREN")
+ self.emit(rparen)
+ return True
+
+ stackref_steal = stackref_close
def sync_sp(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- stack: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
next(tkn_iter)
next(tkn_iter)
next(tkn_iter)
- stack.flush(self.out)
+ storage.clear_inputs("when syncing stack")
+ storage.flush(self.out)
+ self._print_storage(storage)
+ return True
+
+ def emit_save(self, storage: Storage) -> None:
+ storage.save(self.out)
+ self._print_storage(storage)
- def py_stack_ref_from_py_object_new(
+ def save_stack(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- stack: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
- target = uop.deferred_refs[tkn]
- if target is None:
- # An assignment we don't handle, such as to a pointer or array.
- self.out.emit(tkn)
- return
+ ) -> bool:
+ next(tkn_iter)
+ next(tkn_iter)
+ next(tkn_iter)
+ self.emit_save(storage)
+ return True
+
+ def emit_reload(self, storage: Storage) -> None:
+ storage.reload(self.out)
+ self._print_storage(storage)
+
+ def reload_stack(
+ self,
+ tkn: Token,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> bool:
+ next(tkn_iter)
+ next(tkn_iter)
+ next(tkn_iter)
+ self.emit_reload(storage)
+ return True
+ def _print_storage(self, storage: Storage) -> None:
+ if PRINT_STACKS:
+ self.out.start_line()
+ self.emit(storage.as_comment())
+ self.out.start_line()
+
+ def _emit_if(
+ self,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> tuple[bool, Token, Storage]:
+ """Returns (reachable?, closing '}', stack)."""
+ tkn = next(tkn_iter)
+ assert tkn.kind == "LPAREN"
self.out.emit(tkn)
- emit_to(self.out, tkn_iter, "SEMI")
- self.out.emit(";\n")
+ rparen = emit_to(self.out, tkn_iter, "RPAREN")
+ self.emit(rparen)
+ if_storage = storage.copy()
+ reachable, rbrace, if_storage = self._emit_block(tkn_iter, uop, if_storage, inst, True)
+ try:
+ maybe_else = tkn_iter.peek()
+ if maybe_else and maybe_else.kind == "ELSE":
+ self._print_storage(storage)
+ self.emit(rbrace)
+ self.emit(next(tkn_iter))
+ maybe_if = tkn_iter.peek()
+ if maybe_if and maybe_if.kind == "IF":
+ #Emit extra braces around the if to get scoping right
+ self.emit(" {\n")
+ self.emit(next(tkn_iter))
+ else_reachable, rbrace, else_storage = self._emit_if(tkn_iter, uop, storage, inst)
+ self.out.start_line()
+ self.emit("}\n")
+ else:
+ else_reachable, rbrace, else_storage = self._emit_block(tkn_iter, uop, storage, inst, True)
+ if not reachable:
+ # Discard the if storage
+ reachable = else_reachable
+ storage = else_storage
+ elif not else_reachable:
+ # Discard the else storage
+ storage = if_storage
+ reachable = True
+ else:
+ if PRINT_STACKS:
+ self.emit("/* Merge */\n")
+ else_storage.merge(if_storage, self.out)
+ storage = else_storage
+ self._print_storage(storage)
+ else:
+ if reachable:
+ if PRINT_STACKS:
+ self.emit("/* Merge */\n")
+ if_storage.merge(storage, self.out)
+ storage = if_storage
+ self._print_storage(storage)
+ else:
+ # Discard the if storage
+ reachable = True
+ except StackError as ex:
+ self._print_storage(if_storage)
+ raise analysis_error(ex.args[0], rbrace) # from None
+ return reachable, rbrace, storage
+
+ def _emit_block(
+ self,
+ tkn_iter: TokenIterator,
+ uop: Uop,
+ storage: Storage,
+ inst: Instruction | None,
+ emit_first_brace: bool
+ ) -> tuple[bool, Token, Storage]:
+ """ Returns (reachable?, closing '}', stack)."""
+ braces = 1
+ out_stores = set(uop.output_stores)
+ tkn = next(tkn_iter)
+ reload: Token | None = None
+ try:
+ reachable = True
+ line : int = -1
+ if tkn.kind != "LBRACE":
+ raise analysis_error(f"PEP 7: expected '{{', found: {tkn.text}", tkn)
+ escaping_calls = uop.properties.escaping_calls
+ if emit_first_brace:
+ self.emit(tkn)
+ self._print_storage(storage)
+ for tkn in tkn_iter:
+ if PRINT_STACKS and tkn.line != line:
+ self.out.start_line()
+ self.emit(storage.as_comment())
+ self.out.start_line()
+ line = tkn.line
+ if tkn in escaping_calls:
+ if tkn != reload:
+ self.emit_save(storage)
+ _, reload = escaping_calls[tkn]
+ elif tkn == reload:
+ self.emit_reload(storage)
+ if tkn.kind == "LBRACE":
+ self.out.emit(tkn)
+ braces += 1
+ elif tkn.kind == "RBRACE":
+ self._print_storage(storage)
+ braces -= 1
+ if braces == 0:
+ return reachable, tkn, storage
+ self.out.emit(tkn)
+ elif tkn.kind == "GOTO":
+ reachable = False;
+ self.out.emit(tkn)
+ elif tkn.kind == "IDENTIFIER":
+ if tkn.text in self._replacers:
+ if not self._replacers[tkn.text](tkn, tkn_iter, uop, storage, inst):
+ reachable = False
+ else:
+ if tkn in out_stores:
+ for out in storage.outputs:
+ if out.name == tkn.text:
+ out.defined = True
+ out.in_memory = False
+ break
+ if tkn.text.startswith("DISPATCH"):
+ self._print_storage(storage)
+ reachable = False
+ self.out.emit(tkn)
+ elif tkn.kind == "IF":
+ self.out.emit(tkn)
+ if_reachable, rbrace, storage = self._emit_if(tkn_iter, uop, storage, inst)
+ if reachable:
+ reachable = if_reachable
+ self.out.emit(rbrace)
+ else:
+ self.out.emit(tkn)
+ except StackError as ex:
+ raise analysis_error(ex.args[0], tkn) from None
+ raise analysis_error("Expecting closing brace. Reached end of file", tkn)
- # Flush the assignment to the stack. Note that we don't flush the
- # stack pointer here, and instead are currently relying on initializing
- # unused portions of the stack to NULL.
- stack.flush_single_var(self.out, target, uop.stack.outputs)
def emit_tokens(
self,
uop: Uop,
- stack: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
- tkns = uop.body[1:-1]
- if not tkns:
- return
- tkn_iter = iter(tkns)
+ ) -> Storage:
+ tkn_iter = TokenIterator(uop.body)
self.out.start_line()
- for tkn in tkn_iter:
- if tkn.kind == "IDENTIFIER" and tkn.text in self._replacers:
- self._replacers[tkn.text](tkn, tkn_iter, uop, stack, inst)
- else:
- self.out.emit(tkn)
+ _, rbrace, storage = self._emit_block(tkn_iter, uop, storage, inst, False)
+ try:
+ self._print_storage(storage)
+ storage.push_outputs()
+ self._print_storage(storage)
+ except StackError as ex:
+ raise analysis_error(ex.args[0], rbrace)
+ return storage
def emit(self, txt: str | Token) -> None:
self.out.emit(txt)
opmap = {pattern.replace("\\", "") or "\\": op for op, pattern in operators.items()}
# Macros
-macro = r"# *(ifdef|ifndef|undef|define|error|endif|if|else|include|#)"
+macro = r"#.*\n"
CMACRO = "CMACRO"
id_re = r"[a-zA-Z_][0-9a-zA-Z_]*"
line += newlines
else:
begin = line, start - linestart
+ if kind == CMACRO:
+ linestart = end
+ line += 1
if kind != "\n":
yield Token(
filename, kind, text, begin, (line, start - linestart + len(text))
ROOT,
write_header,
Emitter,
+ TokenIterator,
)
from cwriter import CWriter
from typing import TextIO, Iterator
from lexer import Token
-from stack import Local, Stack, StackError
+from stack import Local, Stack, StackError, Storage
DEFAULT_OUTPUT = ROOT / "Python/optimizer_cases.c.h"
DEFAULT_ABSTRACT_INPUT = (ROOT / "Python/optimizer_bytecodes.c").absolute().as_posix()
variables = {"unused"}
if not skip_inputs:
for var in reversed(uop.stack.inputs):
- if var.name not in variables:
+ if var.used and var.name not in variables:
variables.add(var.name)
if var.condition:
out.emit(f"{type_name(var)}{var.name} = NULL;\n")
def decref_inputs(
out: CWriter,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
stack: Stack,
inst: Instruction | None,
out.emit_at("", tkn)
-def emit_default(out: CWriter, uop: Uop) -> None:
- for i, var in enumerate(uop.stack.outputs):
+def emit_default(out: CWriter, uop: Uop, stack: Stack) -> None:
+ for var in reversed(uop.stack.inputs):
+ stack.pop(var)
+ top_offset = stack.top_offset.copy()
+ for var in uop.stack.outputs:
+ if var.is_array() and not var.peek and not var.name == "unused":
+ c_offset = top_offset.to_c()
+ out.emit(f"{var.name} = &stack_pointer[{c_offset}];\n")
+ top_offset.push(var)
+ for var in uop.stack.outputs:
+ local = Local.undefined(var)
+ stack.push(local)
if var.name != "unused" and not var.peek:
+ local.defined = True
if var.is_array():
- out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n")
- out.emit(f"{var.name}[_i] = sym_new_not_null(ctx);\n")
- out.emit("}\n")
+ if var.size == "1":
+ out.emit(f"{var.name}[0] = sym_new_not_null(ctx);\n")
+ else:
+ out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n")
+ out.emit(f"{var.name}[_i] = sym_new_not_null(ctx);\n")
+ out.emit("}\n")
elif var.name == "null":
out.emit(f"{var.name} = sym_new_null(ctx);\n")
else:
class OptimizerEmitter(Emitter):
- pass
+
+ def emit_save(self, storage: Storage) -> None:
+ storage.flush(self.out)
+
+ def emit_reload(self, storage: Storage) -> None:
+ pass
def write_uop(
skip_inputs: bool,
) -> None:
locals: dict[str, Local] = {}
+ prototype = override if override else uop
try:
- prototype = override if override else uop
- is_override = override is not None
out.start_line()
- for var in reversed(prototype.stack.inputs):
- code, local = stack.pop(var, extract_bits=True)
- if not skip_inputs:
+ if override:
+ code_list, storage = Storage.for_uop(stack, prototype, extract_bits=False)
+ for code in code_list:
out.emit(code)
- if local.defined:
- locals[local.name] = local
- out.emit(stack.define_output_arrays(prototype.stack.outputs))
if debug:
args = []
- for var in prototype.stack.inputs:
- if not var.peek or is_override:
- args.append(var.name)
+ for input in prototype.stack.inputs:
+ if not input.peek or override:
+ args.append(input.name)
out.emit(f'DEBUG_PRINTF({", ".join(args)});\n')
if override:
for cache in uop.caches:
out.emit(f"{type}{cache.name} = ({cast})this_instr->operand;\n")
if override:
emitter = OptimizerEmitter(out)
- emitter.emit_tokens(override, stack, None)
+ # No reference management of inputs needed.
+ for var in storage.inputs: # type: ignore[possibly-undefined]
+ var.defined = False
+ storage = emitter.emit_tokens(override, storage, None)
+ out.start_line()
+ storage.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=False)
else:
- emit_default(out, uop)
-
- for var in prototype.stack.outputs:
- if var.name in locals:
- local = locals[var.name]
- else:
- local = Local.local(var)
- stack.push(local)
- out.start_line()
- stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True)
+ emit_default(out, uop, stack)
+ out.start_line()
+ stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=False)
except StackError as ex:
- raise analysis_error(ex.args[0], uop.body[0])
+ raise analysis_error(ex.args[0], prototype.body[0]) # from None
SKIPS = ("_EXTENDED_ARG",)
in_memory: bool
defined: bool
+ def __repr__(self) -> str:
+ return f"Local('{self.item.name}', mem={self.in_memory}, defined={self.defined}, array={self.is_array()})"
+
+ def compact_str(self) -> str:
+ mtag = "M" if self.in_memory else ""
+ dtag = "D" if self.defined else ""
+ atag = "A" if self.is_array() else ""
+ return f"'{self.item.name}'{mtag}{dtag}{atag}"
+
@staticmethod
def unused(defn: StackItem) -> "Local":
return Local(defn, False, defn.is_array(), False)
@staticmethod
- def local(defn: StackItem) -> "Local":
+ def undefined(defn: StackItem) -> "Local":
array = defn.is_array()
- return Local(defn, not array, array, True)
+ return Local(defn, not array, array, False)
@staticmethod
def redefinition(var: StackItem, prev: "Local") -> "Local":
assert var.is_array() == prev.is_array()
return Local(var, prev.cached, prev.in_memory, True)
+ @staticmethod
+ def from_memory(defn: StackItem) -> "Local":
+ return Local(defn, True, True, True)
+
+ def copy(self) -> "Local":
+ return Local(
+ self.item,
+ self.cached,
+ self.in_memory,
+ self.defined
+ )
+
@property
def size(self) -> str:
return self.item.size
def is_array(self) -> bool:
return self.item.is_array()
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, Local):
+ return NotImplemented
+ return (
+ self.item is other.item
+ and self.cached is other.cached
+ and self.in_memory is other.in_memory
+ and self.defined is other.defined
+ )
+
@dataclass
class StackOffset:
res = "-" + res[3:]
return res
+ def as_int(self) -> int | None:
+ self.simplify()
+ int_offset = 0
+ for item in self.popped:
+ try:
+ int_offset -= int(item)
+ except ValueError:
+ return None
+ for item in self.pushed:
+ try:
+ int_offset += int(item)
+ except ValueError:
+ return None
+ return int_offset
+
def clear(self) -> None:
self.popped = []
self.pushed = []
+ def __bool__(self) -> bool:
+ self.simplify()
+ return bool(self.popped) or bool(self.pushed)
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, StackOffset):
+ return NotImplemented
+ return self.to_c() == other.to_c()
+
class StackError(Exception):
pass
self.variables: list[Local] = []
self.defined: set[str] = set()
- def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]:
+ def pop(self, var: StackItem, extract_bits: bool = True) -> tuple[str, Local]:
self.top_offset.pop(var)
indirect = "&" if var.is_array() else ""
if self.variables:
if var.name in UNUSED:
if popped.name not in UNUSED and popped.name in self.defined:
raise StackError(
- f"Value is declared unused, but is already cached by prior operation"
+ f"Value is declared unused, but is already cached by prior operation as '{popped.name}'"
)
return "", popped
if not var.used:
defn = f"{var.name} = &stack_pointer[{self.top_offset.to_c()}];\n"
else:
defn = f"{var.name} = stack_pointer[{self.top_offset.to_c()}];\n"
+ popped.in_memory = True
return defn, Local.redefinition(var, popped)
self.base_offset.pop(var)
return "", Local.unused(var)
self.defined.add(var.name)
cast = f"({var.type})" if (not indirect and var.type) else ""
- bits = ".bits" if cast and not extract_bits else ""
+ bits = ".bits" if cast and extract_bits else ""
assign = f"{var.name} = {cast}{indirect}stack_pointer[{self.base_offset.to_c()}]{bits};"
if var.condition:
if var.condition == "1":
assign = f"if ({var.condition}) {{ {assign} }}\n"
else:
assign = f"{assign}\n"
- in_memory = var.is_array() or var.peek
- return assign, Local(var, not var.is_array(), in_memory, True)
+ return assign, Local.from_memory(var)
def push(self, var: Local) -> None:
+ assert(var not in self.variables)
self.variables.append(var)
self.top_offset.push(var.item)
if var.item.used:
self.defined.add(var.name)
- var.defined = True
-
- def define_output_arrays(self, outputs: list[StackItem]) -> str:
- res = []
- top_offset = self.top_offset.copy()
- for var in outputs:
- if var.is_array() and var.used and not var.peek:
- c_offset = top_offset.to_c()
- top_offset.push(var)
- res.append(f"{var.name} = &stack_pointer[{c_offset}];\n")
- else:
- top_offset.push(var)
- return "\n".join(res)
@staticmethod
def _do_emit(
var: StackItem,
base_offset: StackOffset,
cast_type: str = "uintptr_t",
- extract_bits: bool = False,
+ extract_bits: bool = True,
) -> None:
cast = f"({cast_type})" if var.type else ""
- bits = ".bits" if cast and not extract_bits else ""
+ bits = ".bits" if cast and extract_bits else ""
if var.condition == "0":
return
if var.condition and var.condition != "1":
out.emit(f"if ({var.condition}) ")
out.emit(f"stack_pointer[{base_offset.to_c()}]{bits} = {cast}{var.name};\n")
- @staticmethod
- def _do_flush(
- out: CWriter,
- variables: list[Local],
- base_offset: StackOffset,
- top_offset: StackOffset,
- cast_type: str = "uintptr_t",
- extract_bits: bool = False,
- ) -> None:
- out.start_line()
- for var in variables:
- if (
- var.cached
- and not var.in_memory
- and not var.item.peek
- and not var.name in UNUSED
- ):
- Stack._do_emit(out, var.item, base_offset, cast_type, extract_bits)
- base_offset.push(var.item)
- if base_offset.to_c() != top_offset.to_c():
- print("base", base_offset, "top", top_offset)
- assert False
- number = base_offset.to_c()
+ def _adjust_stack_pointer(self, out: CWriter, number: str) -> None:
if number != "0":
+ out.start_line()
out.emit(f"stack_pointer += {number};\n")
out.emit("assert(WITHIN_STACK_BOUNDS());\n")
- out.start_line()
-
- def flush_locally(
- self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = False
- ) -> None:
- self._do_flush(
- out,
- self.variables[:],
- self.base_offset.copy(),
- self.top_offset.copy(),
- cast_type,
- extract_bits,
- )
def flush(
- self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = False
+ self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = True
) -> None:
- self._do_flush(
- out,
- self.variables,
- self.base_offset,
- self.top_offset,
- cast_type,
- extract_bits,
- )
- self.variables = []
- self.base_offset.clear()
+ out.start_line()
+ var_offset = self.base_offset.copy()
+ for var in self.variables:
+ if (
+ var.defined and
+ not var.in_memory
+ ):
+ Stack._do_emit(out, var.item, var_offset, cast_type, extract_bits)
+ var.in_memory = True
+ var_offset.push(var.item)
+ number = self.top_offset.to_c()
+ self._adjust_stack_pointer(out, number)
+ self.base_offset -= self.top_offset
self.top_offset.clear()
+ out.start_line()
- def flush_single_var(
- self,
- out: CWriter,
- var_name: str,
- outputs: list[StackItem],
- cast_type: str = "uintptr_t",
- extract_bits: bool = False,
- ) -> None:
- assert any(var.name == var_name for var in outputs)
- base_offset = self.base_offset.copy()
- top_offset = self.top_offset.copy()
- for var in self.variables:
- base_offset.push(var.item)
- for output in outputs:
- if any(output == v.item for v in self.variables):
- # The variable is already on the stack, such as a peeked value
- # in the tier1 generator
- continue
- if output.name == var_name:
- Stack._do_emit(out, output, base_offset, cast_type, extract_bits)
- base_offset.push(output)
- top_offset.push(output)
- if base_offset.to_c() != top_offset.to_c():
- print("base", base_offset, "top", top_offset)
- assert False
+ def is_flushed(self) -> bool:
+ return not self.variables and not self.base_offset and not self.top_offset
def peek_offset(self) -> str:
return self.top_offset.to_c()
def as_comment(self) -> str:
- return f"/* Variables: {[v.name for v in self.variables]}. Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */"
+ variables = ", ".join([v.compact_str() for v in self.variables])
+ return (
+ f"/* Variables: {variables}. base: {self.base_offset.to_c()}. top: {self.top_offset.to_c()} */"
+ )
+
+ def copy(self) -> "Stack":
+ other = Stack()
+ other.top_offset = self.top_offset.copy()
+ other.base_offset = self.base_offset.copy()
+ other.variables = [var.copy() for var in self.variables]
+ other.defined = set(self.defined)
+ return other
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, Stack):
+ return NotImplemented
+ return (
+ self.top_offset == other.top_offset
+ and self.base_offset == other.base_offset
+ and self.variables == other.variables
+ )
+
+ def align(self, other: "Stack", out: CWriter) -> None:
+ if len(self.variables) != len(other.variables):
+ raise StackError("Cannot align stacks: differing variables")
+ if self.top_offset == other.top_offset:
+ return
+ diff = self.top_offset - other.top_offset
+ try:
+ self.top_offset -= diff
+ self.base_offset -= diff
+ self._adjust_stack_pointer(out, diff.to_c())
+ except ValueError:
+ raise StackError("Cannot align stacks: cannot adjust stack pointer")
+
+ def merge(self, other: "Stack", out: CWriter) -> None:
+ if len(self.variables) != len(other.variables):
+ raise StackError("Cannot merge stacks: differing variables")
+ for self_var, other_var in zip(self.variables, other.variables):
+ if self_var.name != other_var.name:
+ raise StackError(f"Mismatched variables on stack: {self_var.name} and {other_var.name}")
+ self_var.defined = self_var.defined and other_var.defined
+ self_var.in_memory = self_var.in_memory and other_var.in_memory
+ self.align(other, out)
def get_stack_effect(inst: Instruction | PseudoInstruction) -> Stack:
local = Local.unused(var)
stack.push(local)
return stack
+
+@dataclass
+class Storage:
+
+ stack: Stack
+ inputs: list[Local]
+ outputs: list[Local]
+ peeks: list[Local]
+ spilled: int = 0
+
+ @staticmethod
+ def needs_defining(var: Local) -> bool:
+ return (
+ not var.defined and
+ not var.is_array() and
+ var.name != "unused"
+ )
+
+ @staticmethod
+ def is_live(var: Local) -> bool:
+ return (
+ var.defined and
+ var.name != "unused"
+ )
+
+ def first_input_not_cleared(self) -> str:
+ for input in self.inputs:
+ if input.defined:
+ return input.name
+ return ""
+
+ def clear_inputs(self, reason:str) -> None:
+ while self.inputs:
+ tos = self.inputs.pop()
+ if self.is_live(tos) and not tos.is_array():
+ raise StackError(
+ f"Input '{tos.name}' is still live {reason}"
+ )
+ self.stack.pop(tos.item)
+
+ def clear_dead_inputs(self) -> None:
+ live = ""
+ while self.inputs:
+ tos = self.inputs[-1]
+ if self.is_live(tos):
+ live = tos.name
+ break
+ self.inputs.pop()
+ self.stack.pop(tos.item)
+ for var in self.inputs:
+ if not var.defined and not var.is_array() and var.name != "unused":
+ raise StackError(
+ f"Input '{var.name}' is not live, but '{live}' is"
+ )
+
+ def _push_defined_outputs(self) -> None:
+ defined_output = ""
+ for output in self.outputs:
+ if output.defined and not output.in_memory:
+ defined_output = output.name
+ if not defined_output:
+ return
+ self.clear_inputs(f"when output '{defined_output}' is defined")
+ undefined = ""
+ for out in self.outputs:
+ if out.defined:
+ if undefined:
+ f"Locals not defined in stack order. "
+ f"Expected '{undefined}' to be defined before '{out.name}'"
+ else:
+ undefined = out.name
+ while self.outputs and not self.needs_defining(self.outputs[0]):
+ out = self.outputs.pop(0)
+ self.stack.push(out)
+
+ def locals_cached(self) -> bool:
+ for out in self.outputs:
+ if out.defined:
+ return True
+ return False
+
+ def flush(self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = True) -> None:
+ self.clear_dead_inputs()
+ self._push_defined_outputs()
+ self.stack.flush(out, cast_type, extract_bits)
+
+ def save(self, out: CWriter) -> None:
+ assert self.spilled >= 0
+ if self.spilled == 0:
+ self.flush(out)
+ out.start_line()
+ out.emit("_PyFrame_SetStackPointer(frame, stack_pointer);\n")
+ self.spilled += 1
+
+ def reload(self, out: CWriter) -> None:
+ if self.spilled == 0:
+ raise StackError("Cannot reload stack as it hasn't been saved")
+ assert self.spilled > 0
+ self.spilled -= 1
+ if self.spilled == 0:
+ out.start_line()
+ out.emit("stack_pointer = _PyFrame_GetStackPointer(frame);\n")
+
+ @staticmethod
+ def for_uop(stack: Stack, uop: Uop, extract_bits: bool = True) -> tuple[list[str], "Storage"]:
+ code_list: list[str] = []
+ inputs: list[Local] = []
+ peeks: list[Local] = []
+ for input in reversed(uop.stack.inputs):
+ code, local = stack.pop(input, extract_bits)
+ code_list.append(code)
+ if input.peek:
+ peeks.append(local)
+ else:
+ inputs.append(local)
+ inputs.reverse()
+ peeks.reverse()
+ for peek in peeks:
+ stack.push(peek)
+ top_offset = stack.top_offset.copy()
+ for ouput in uop.stack.outputs:
+ if ouput.is_array() and ouput.used and not ouput.peek:
+ c_offset = top_offset.to_c()
+ top_offset.push(ouput)
+ code_list.append(f"{ouput.name} = &stack_pointer[{c_offset}];\n")
+ else:
+ top_offset.push(ouput)
+ for var in inputs:
+ stack.push(var)
+ outputs = [ Local.undefined(var) for var in uop.stack.outputs if not var.peek ]
+ return code_list, Storage(stack, inputs, outputs, peeks)
+
+ @staticmethod
+ def copy_list(arg: list[Local]) -> list[Local]:
+ return [ l.copy() for l in arg ]
+
+ def copy(self) -> "Storage":
+ new_stack = self.stack.copy()
+ variables = { var.name: var for var in new_stack.variables }
+ inputs = [ variables[var.name] for var in self.inputs]
+ assert [v.name for v in inputs] == [v.name for v in self.inputs], (inputs, self.inputs)
+ return Storage(
+ new_stack, inputs,
+ self.copy_list(self.outputs), self.copy_list(self.peeks)
+ )
+
+ def sanity_check(self) -> None:
+ names: set[str] = set()
+ for var in self.inputs:
+ if var.name in names:
+ raise StackError(f"Duplicate name {var.name}")
+ names.add(var.name)
+ names = set()
+ for var in self.outputs:
+ if var.name in names:
+ raise StackError(f"Duplicate name {var.name}")
+ names.add(var.name)
+ names = set()
+ for var in self.stack.variables:
+ if var.name in names:
+ raise StackError(f"Duplicate name {var.name}")
+ names.add(var.name)
+
+ def is_flushed(self) -> bool:
+ for var in self.outputs:
+ if var.defined and not var.in_memory:
+ return False
+ return self.stack.is_flushed()
+
+ def merge(self, other: "Storage", out: CWriter) -> None:
+ self.sanity_check()
+ if len(self.inputs) != len(other.inputs):
+ self.clear_dead_inputs()
+ other.clear_dead_inputs()
+ if len(self.inputs) != len(other.inputs):
+ diff = self.inputs[-1] if len(self.inputs) > len(other.inputs) else other.inputs[-1]
+ raise StackError(f"Unmergeable inputs. Differing state of '{diff.name}'")
+ for var, other_var in zip(self.inputs, other.inputs):
+ if var.defined != other_var.defined:
+ raise StackError(f"'{var.name}' is cleared on some paths, but not all")
+ if len(self.outputs) != len(other.outputs):
+ self._push_defined_outputs()
+ other._push_defined_outputs()
+ if len(self.outputs) != len(other.outputs):
+ var = self.outputs[0] if len(self.outputs) > len(other.outputs) else other.outputs[0]
+ raise StackError(f"'{var.name}' is set on some paths, but not all")
+ self.stack.merge(other.stack, out)
+ self.sanity_check()
+
+ def push_outputs(self) -> None:
+ if self.spilled:
+ raise StackError(f"Unbalanced stack spills")
+ self.clear_inputs("at the end of the micro-op")
+ if self.inputs:
+ raise StackError(f"Input variable '{self.inputs[-1].name}' is still live")
+ self._push_defined_outputs()
+ if self.outputs:
+ for out in self.outputs:
+ if self.needs_defining(out):
+ raise StackError(f"Output variable '{self.outputs[0].name}' is not defined")
+ self.stack.push(out)
+ self.outputs = []
+
+ def as_comment(self) -> str:
+ stack_comment = self.stack.as_comment()
+ next_line = "\n "
+ inputs = ", ".join([var.compact_str() for var in self.inputs])
+ outputs = ", ".join([var.compact_str() for var in self.outputs])
+ peeks = ", ".join([var.name for var in self.peeks])
+ return f"{stack_comment[:-2]}{next_line}inputs: {inputs}{next_line}outputs: {outputs}{next_line}peeks: {peeks} */"
write_header,
type_and_null,
Emitter,
+ TokenIterator,
)
from cwriter import CWriter
from typing import TextIO
-from stack import Local, Stack, StackError, get_stack_effect
+from stack import Local, Stack, StackError, get_stack_effect, Storage
DEFAULT_OUTPUT = ROOT / "Python/generated_cases.c.h"
try:
stack = get_stack_effect(inst)
except StackError as ex:
- raise analysis_error(ex.args[0], inst.where)
+ raise analysis_error(ex.args[0], inst.where) from None
required = set(stack.defined)
required.discard("unused")
for part in inst.parts:
stack: Stack,
inst: Instruction,
braces: bool,
-) -> int:
+) -> tuple[int, Stack]:
# out.emit(stack.as_comment() + "\n")
if isinstance(uop, Skip):
entries = "entries" if uop.size > 1 else "entry"
emitter.emit(f"/* Skip {uop.size} cache {entries} */\n")
- return offset + uop.size
+ return (offset + uop.size), stack
if isinstance(uop, Flush):
emitter.emit(f"// flush\n")
stack.flush(emitter.out)
- return offset
+ return offset, stack
try:
locals: dict[str, Local] = {}
emitter.out.start_line()
if braces:
emitter.out.emit(f"// {uop.name}\n")
- peeks: list[Local] = []
- for var in reversed(uop.stack.inputs):
- code, local = stack.pop(var)
- emitter.emit(code)
- if var.peek:
- peeks.append(local)
- if local.defined:
- locals[local.name] = local
- # Push back the peeks, so that they remain on the logical
- # stack, but their values are cached.
- while peeks:
- stack.push(peeks.pop())
- if braces:
emitter.emit("{\n")
- emitter.out.emit(stack.define_output_arrays(uop.stack.outputs))
- outputs: list[Local] = []
- for var in uop.stack.outputs:
- if not var.peek:
- if var.name in locals:
- local = locals[var.name]
- elif var.name == "unused":
- local = Local.unused(var)
- else:
- local = Local.local(var)
- outputs.append(local)
+ code_list, storage = Storage.for_uop(stack, uop)
+ emitter._print_storage(storage)
+ for code in code_list:
+ emitter.emit(code)
for cache in uop.caches:
if cache.name != "unused":
if inst.family is None:
emitter.emit(f"(void){cache.name};\n")
offset += cache.size
- emitter.emit_tokens(uop, stack, inst)
- for output in outputs:
- if output.name in uop.deferred_refs.values():
- # We've already spilled this when emitting tokens
- output.cached = False
- stack.push(output)
+
+ storage = emitter.emit_tokens(uop, storage, inst)
if braces:
emitter.out.start_line()
emitter.emit("}\n")
# emitter.emit(stack.as_comment() + "\n")
- return offset
+ return offset, storage.stack
except StackError as ex:
raise analysis_error(ex.args[0], uop.body[0])
for part in inst.parts:
# Only emit braces if more than one uop
insert_braces = len([p for p in inst.parts if isinstance(p, Uop)]) > 1
- offset = write_uop(part, emitter, offset, stack, inst, insert_braces)
+ offset, stack = write_uop(part, emitter, offset, stack, inst, insert_braces)
out.start_line()
+
+ stack.flush(out)
if not inst.parts[-1].properties.always_exits:
- stack.flush(out)
out.emit("DISPATCH();\n")
out.start_line()
out.emit("}")
write_header,
type_and_null,
Emitter,
+ TokenIterator,
+ always_true,
)
from cwriter import CWriter
from typing import TextIO, Iterator
from lexer import Token
-from stack import Local, Stack, StackError, get_stack_effect
+from stack import Local, Stack, StackError, Storage
DEFAULT_OUTPUT = ROOT / "Python/executor_cases.c.h"
def declare_variable(
var: StackItem, uop: Uop, required: set[str], out: CWriter
) -> None:
- if var.name not in required:
+ if not var.used or var.name not in required:
return
required.remove(var.name)
type, null = type_and_null(var)
for var in reversed(uop.stack.inputs):
stack.pop(var)
for var in uop.stack.outputs:
- stack.push(Local.unused(var))
+ stack.push(Local.undefined(var))
required = set(stack.defined)
required.discard("unused")
for var in reversed(uop.stack.inputs):
def error_if(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- stack: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
self.out.emit_at("if ", tkn)
- self.emit(next(tkn_iter))
+ lparen = next(tkn_iter)
+ self.emit(lparen)
+ assert lparen.kind == "LPAREN"
+ first_tkn = next(tkn_iter)
+ self.out.emit(first_tkn)
emit_to(self.out, tkn_iter, "COMMA")
label = next(tkn_iter).text
next(tkn_iter) # RPAREN
next(tkn_iter) # Semi colon
self.emit(") JUMP_TO_ERROR();\n")
+ return not always_true(first_tkn)
+
def error_no_pop(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- stack: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
next(tkn_iter) # LPAREN
next(tkn_iter) # RPAREN
next(tkn_iter) # Semi colon
self.out.emit_at("JUMP_TO_ERROR();", tkn)
+ return False
def deopt_if(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- unused: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
self.out.emit_at("if ", tkn)
- self.emit(next(tkn_iter))
+ lparen = next(tkn_iter)
+ self.emit(lparen)
+ assert lparen.kind == "LPAREN"
+ first_tkn = tkn_iter.peek()
emit_to(self.out, tkn_iter, "RPAREN")
next(tkn_iter) # Semi colon
self.emit(") {\n")
self.emit("UOP_STAT_INC(uopcode, miss);\n")
self.emit("JUMP_TO_JUMP_TARGET();\n")
self.emit("}\n")
+ return not always_true(first_tkn)
def exit_if( # type: ignore[override]
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- unused: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
self.out.emit_at("if ", tkn)
- self.emit(next(tkn_iter))
+ lparen = next(tkn_iter)
+ self.emit(lparen)
+ first_tkn = tkn_iter.peek()
emit_to(self.out, tkn_iter, "RPAREN")
next(tkn_iter) # Semi colon
self.emit(") {\n")
self.emit("UOP_STAT_INC(uopcode, miss);\n")
self.emit("JUMP_TO_JUMP_TARGET();\n")
self.emit("}\n")
+ return not always_true(first_tkn)
def oparg(
self,
tkn: Token,
- tkn_iter: Iterator[Token],
+ tkn_iter: TokenIterator,
uop: Uop,
- unused: Stack,
+ storage: Storage,
inst: Instruction | None,
- ) -> None:
+ ) -> bool:
if not uop.name.endswith("_0") and not uop.name.endswith("_1"):
self.emit(tkn)
- return
+ return True
amp = next(tkn_iter)
if amp.text != "&":
self.emit(tkn)
self.emit(amp)
- return
+ return True
one = next(tkn_iter)
assert one.text == "1"
self.out.emit_at(uop.name[-1], tkn)
+ return True
-def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None:
+def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> Stack:
locals: dict[str, Local] = {}
try:
emitter.out.start_line()
elif uop.properties.const_oparg >= 0:
emitter.emit(f"oparg = {uop.properties.const_oparg};\n")
emitter.emit(f"assert(oparg == CURRENT_OPARG());\n")
- for var in reversed(uop.stack.inputs):
- code, local = stack.pop(var)
+ code_list, storage = Storage.for_uop(stack, uop)
+ for code in code_list:
emitter.emit(code)
- if local.defined:
- locals[local.name] = local
- emitter.emit(stack.define_output_arrays(uop.stack.outputs))
- outputs: list[Local] = []
- for var in uop.stack.outputs:
- if var.name in locals:
- local = locals[var.name]
- else:
- local = Local.local(var)
- outputs.append(local)
for cache in uop.caches:
if cache.name != "unused":
if cache.size == 4:
type = f"uint{cache.size*16}_t "
cast = f"uint{cache.size*16}_t"
emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")
- emitter.emit_tokens(uop, stack, None)
- for output in outputs:
- if output.name in uop.deferred_refs.values():
- # We've already spilled this when emitting tokens
- output.cached = False
- stack.push(output)
+ storage = emitter.emit_tokens(uop, storage, None)
except StackError as ex:
raise analysis_error(ex.args[0], uop.body[0]) from None
-
+ return storage.stack
SKIPS = ("_EXTENDED_ARG",)
out.emit(f"case {uop.name}: {{\n")
declare_variables(uop, out)
stack = Stack()
- write_uop(uop, emitter, stack)
+ stack = write_uop(uop, emitter, stack)
out.start_line()
if not uop.properties.always_exits:
stack.flush(out)
projects / thirdparty / Python / cpython.git / commitdiff
