From 76e5f9a674625e1e009ab08ca1ca9f689634bb4b Mon Sep 17 00:00:00 2001 From: Brandt Bucher Date: Wed, 16 Apr 2025 13:37:29 -0700 Subject: [PATCH] Replace uses of array[1]s with scalars in bytecode definitions --- Include/internal/pycore_uop_metadata.h | 2 +- Python/bytecodes.c | 272 +++++---- Python/executor_cases.c.h | 644 +++++++++++---------- Python/generated_cases.c.h | 748 +++++++++++++------------ Python/optimizer_bytecodes.c | 16 +- Python/optimizer_cases.c.h | 33 +- Tools/cases_generator/stack.py | 22 +- 7 files changed, 911 insertions(+), 826 deletions(-) diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index ab26543a26fa98..874756770c1871 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -1067,7 +1067,7 @@ int _PyUop_num_popped(int opcode, int oparg) case _CALL_METHOD_DESCRIPTOR_FAST: return 2 + oparg; case _MAYBE_EXPAND_METHOD_KW: - return 1; + return 0; case _PY_FRAME_KW: return 3 + oparg; case _CHECK_FUNCTION_VERSION_KW: diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 95786c91371e98..6100b47cfa2e7c 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -425,7 +425,6 @@ dummy_func( } pure inst(END_SEND, (receiver, value -- val)) { - (void)receiver; val = value; DEAD(value); PyStackRef_CLOSE(receiver); @@ -3636,11 +3635,11 @@ dummy_func( CALL_NON_PY_GENERAL, }; - specializing op(_SPECIALIZE_CALL, (counter/1, callable[1], self_or_null[1], args[oparg] -- callable[1], self_or_null[1], args[oparg])) { + specializing op(_SPECIALIZE_CALL, (counter/1, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { #if ENABLE_SPECIALIZATION_FT if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; - _Py_Specialize_Call(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); + _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null)); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL); @@ -3648,27 +3647,26 @@ dummy_func( #endif /* ENABLE_SPECIALIZATION_FT */ } - op(_MAYBE_EXPAND_METHOD, (callable[1], self_or_null[1], args[oparg] -- callable[1], self_or_null[1], args[oparg])) { - (void)args; - if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_MAYBE_EXPAND_METHOD, (callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null[0] = PyStackRef_FromPyObjectNew(self); + self_or_null = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(method); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); PyStackRef_CLOSE(temp); } } // When calling Python, inline the call using DISPATCH_INLINED(). - op(_DO_CALL, (callable[1], self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_DO_CALL, (callable, self_or_null, args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -3680,7 +3678,7 @@ dummy_func( 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[0], locals, + tstate, callable, locals, arguments, total_args, NULL, frame ); DEAD(args); @@ -3730,12 +3728,12 @@ dummy_func( res = PyStackRef_FromPyObjectSteal(res_o); } - 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[0]); + op(_MONITOR_CALL, (func, maybe_self, args[oparg] -- func, maybe_self, args[oparg])) { + int is_meth = !PyStackRef_IsNull(maybe_self); + PyObject *function = PyStackRef_AsPyObjectBorrow(func); PyObject *arg0; if (is_meth) { - arg0 = PyStackRef_AsPyObjectBorrow(maybe_self[0]); + arg0 = PyStackRef_AsPyObjectBorrow(maybe_self); } else if (oparg) { arg0 = PyStackRef_AsPyObjectBorrow(args[0]); @@ -3754,12 +3752,12 @@ dummy_func( 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[1], self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_PY_FRAME_GENERAL, (callable, self_or_null, args[oparg] -- new_frame: _PyInterpreterFrame*)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -3767,7 +3765,7 @@ dummy_func( 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 *temp = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, args, total_args, NULL, frame ); // The frame has stolen all the arguments from the stack. @@ -3779,8 +3777,8 @@ dummy_func( new_frame = temp; } - 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]); + op(_CHECK_FUNCTION_VERSION, (func_version/2, callable, unused, unused[oparg] -- callable, unused, unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); EXIT_IF(!PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; EXIT_IF(func->func_version != func_version); @@ -3800,24 +3798,24 @@ dummy_func( _SAVE_RETURN_OFFSET + _PUSH_FRAME; - 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]); + op(_CHECK_METHOD_VERSION, (func_version/2, callable, null, unused[oparg] -- callable, null, unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); EXIT_IF(Py_TYPE(callable_o) != &PyMethod_Type); PyObject *func = ((PyMethodObject *)callable_o)->im_func; EXIT_IF(!PyFunction_Check(func)); EXIT_IF(((PyFunctionObject *)func)->func_version != func_version); - EXIT_IF(!PyStackRef_IsNull(null[0])); + EXIT_IF(!PyStackRef_IsNull(null)); } - op(_EXPAND_METHOD, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); - assert(PyStackRef_IsNull(self_or_null[0])); + op(_EXPAND_METHOD, (callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + assert(PyStackRef_IsNull(self_or_null)); assert(Py_TYPE(callable_o) == &PyMethod_Type); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(callable[0])); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(callable)); PyStackRef_CLOSE(temp); } @@ -3831,21 +3829,21 @@ dummy_func( _SAVE_RETURN_OFFSET + _PUSH_FRAME; - 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]); + op(_CHECK_IS_NOT_PY_CALLABLE, (callable, unused, unused[oparg] -- callable, unused, unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); EXIT_IF(PyFunction_Check(callable_o)); EXIT_IF(Py_TYPE(callable_o) == &PyMethod_Type); } - op(_CALL_NON_PY_GENERAL, (callable[1], self_or_null[1], args[oparg] -- res)) { + op(_CALL_NON_PY_GENERAL, (callable, self_or_null, args[oparg] -- res)) { #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -3873,18 +3871,18 @@ dummy_func( _CALL_NON_PY_GENERAL + _CHECK_PERIODIC; - 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[0])) != &PyMethod_Type); + op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null, unused[oparg] -- callable, null, unused[oparg])) { + EXIT_IF(!PyStackRef_IsNull(null)); + EXIT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type); } - op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) { - assert(PyStackRef_IsNull(self_or_null[0])); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { + assert(PyStackRef_IsNull(self_or_null)); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); STAT_INC(CALL, hit); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); PyStackRef_CLOSE(temp); } @@ -3892,28 +3890,28 @@ dummy_func( DEOPT_IF(tstate->interp->eval_frame); } - 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]); + op(_CHECK_FUNCTION_EXACT_ARGS, (callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); 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]))); + EXIT_IF(code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null))); } - 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]); + op(_CHECK_STACK_SPACE, (callable, unused, unused[oparg] -- callable, unused, unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); 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[1], self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) { - int has_self = !PyStackRef_IsNull(self_or_null[0]); + replicate(5) pure op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null, args[oparg] -- new_frame: _PyInterpreterFrame*)) { + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -4018,10 +4016,9 @@ dummy_func( _CALL_TUPLE_1 + _CHECK_PERIODIC; - op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable[1], self_or_null[1], args[oparg] -- callable[1], self_or_null[1], args[oparg])) { - (void)args; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); - DEOPT_IF(!PyStackRef_IsNull(self_or_null[0])); + op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + DEOPT_IF(!PyStackRef_IsNull(self_or_null)); DEOPT_IF(!PyType_Check(callable_o)); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(FT_ATOMIC_LOAD_UINT32_RELAXED(tp->tp_version_tag) != type_version); @@ -4037,21 +4034,21 @@ dummy_func( if (self_o == NULL) { ERROR_NO_POP(); } - self_or_null[0] = PyStackRef_FromPyObjectSteal(self_o); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(init_func); + self_or_null = PyStackRef_FromPyObjectSteal(self_o); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(init_func); PyStackRef_CLOSE(temp); } - op(_CREATE_INIT_FRAME, (init[1], self[1], args[oparg] -- init_frame: _PyInterpreterFrame *)) { + op(_CREATE_INIT_FRAME, (init, self, args[oparg] -- init_frame: _PyInterpreterFrame *)) { _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); assert(_PyFrame_GetBytecode(shim)[0].op.code == EXIT_INIT_CHECK); assert(_PyFrame_GetBytecode(shim)[1].op.code == RETURN_VALUE); /* Push self onto stack of shim */ - shim->localsplus[0] = PyStackRef_DUP(self[0]); + shim->localsplus[0] = PyStackRef_DUP(self); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, init[0], NULL, args-1, oparg+1, NULL, shim); + tstate, init, NULL, args-1, oparg+1, NULL, shim); DEAD(init); DEAD(self); DEAD(args); @@ -4085,13 +4082,13 @@ dummy_func( DEAD(should_be_none); } - op(_CALL_BUILTIN_CLASS, (callable[1], self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_CALL_BUILTIN_CLASS, (callable, self_or_null, args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(!PyType_Check(callable_o)); PyTypeObject *tp = (PyTypeObject *)callable_o; int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4115,12 +4112,12 @@ dummy_func( _CALL_BUILTIN_CLASS + _CHECK_PERIODIC; - op(_CALL_BUILTIN_O, (callable[1], self_or_null[1], args[oparg] -- res)) { + op(_CALL_BUILTIN_O, (callable, self_or_null, args[oparg] -- res)) { /* Builtin METH_O functions */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -4139,7 +4136,7 @@ dummy_func( PyStackRef_CLOSE(arg); DEAD(args); DEAD(self_or_null); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -4150,13 +4147,13 @@ dummy_func( _CALL_BUILTIN_O + _CHECK_PERIODIC; - op(_CALL_BUILTIN_FAST, (callable[1], self_or_null[1], args[oparg] -- res)) { + op(_CALL_BUILTIN_FAST, (callable, self_or_null, args[oparg] -- res)) { /* Builtin METH_FASTCALL functions, without keywords */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4187,13 +4184,13 @@ dummy_func( _CALL_BUILTIN_FAST + _CHECK_PERIODIC; - op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable[1], self_or_null[1], args[oparg] -- res)) { + op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable, self_or_null, args[oparg] -- res)) { /* Builtin METH_FASTCALL | METH_KEYWORDS functions */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4224,12 +4221,12 @@ dummy_func( _CALL_BUILTIN_FAST_WITH_KEYWORDS + _CHECK_PERIODIC; - inst(CALL_LEN, (unused/1, unused/2, callable[1], self_or_null[1], args[oparg] -- res)) { + inst(CALL_LEN, (unused/1, unused/2, callable, self_or_null, args[oparg] -- res)) { /* len(o) */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -4251,17 +4248,17 @@ dummy_func( PyStackRef_CLOSE(arg_stackref); DEAD(args); DEAD(self_or_null); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); 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, self_or_null, args[oparg] -- res)) { /* isinstance(o, o2) */ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4305,12 +4302,12 @@ dummy_func( #endif } - op(_CALL_METHOD_DESCRIPTOR_O, (callable[1], self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_CALL_METHOD_DESCRIPTOR_O, (callable, self_or_null, args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4344,12 +4341,12 @@ dummy_func( _CALL_METHOD_DESCRIPTOR_O + _CHECK_PERIODIC; - op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable[1], self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable, self_or_null, args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4386,12 +4383,12 @@ dummy_func( _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS + _CHECK_PERIODIC; - op(_CALL_METHOD_DESCRIPTOR_NOARGS, (callable[1], self_or_null[1], args[oparg] -- res)) { + op(_CALL_METHOD_DESCRIPTOR_NOARGS, (callable, self_or_null, args[oparg] -- res)) { assert(oparg == 0 || oparg == 1); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -4413,7 +4410,7 @@ dummy_func( PyStackRef_CLOSE(self_stackref); DEAD(args); DEAD(self_or_null); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -4424,12 +4421,12 @@ dummy_func( _CALL_METHOD_DESCRIPTOR_NOARGS + _CHECK_PERIODIC; - op(_CALL_METHOD_DESCRIPTOR_FAST, (callable[1], self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_CALL_METHOD_DESCRIPTOR_FAST, (callable, self_or_null, args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4473,11 +4470,11 @@ dummy_func( CALL_KW_NON_PY, }; - op(_MONITOR_CALL_KW, (callable[1], self_or_null[1], args[oparg], kwnames -- callable[1], self_or_null[1], args[oparg], kwnames)) { - int is_meth = !PyStackRef_IsNull(self_or_null[0]); + op(_MONITOR_CALL_KW, (callable, self_or_null, args[oparg], unused -- callable, self_or_null, args[oparg], unused)) { + int is_meth = !PyStackRef_IsNull(self_or_null); PyObject *arg; if (is_meth) { - arg = PyStackRef_AsPyObjectBorrow(self_or_null[0]); + arg = PyStackRef_AsPyObjectBorrow(self_or_null); } else if (args) { arg = PyStackRef_AsPyObjectBorrow(args[0]); @@ -4485,36 +4482,33 @@ dummy_func( else { arg = &_PyInstrumentation_MISSING; } - PyObject *function = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *function = PyStackRef_AsPyObjectBorrow(callable); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, function, arg); ERROR_IF(err, error); } - op(_MAYBE_EXPAND_METHOD_KW, (callable[1], self_or_null[1], args[oparg], kwnames_in -- callable[1], self_or_null[1], args[oparg], kwnames_out)) { - (void)args; - if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_MAYBE_EXPAND_METHOD_KW, (callable, self_or_null, unused[oparg], unused -- callable, self_or_null, unused[oparg], unused)) { + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null[0] = PyStackRef_FromPyObjectNew(self); + self_or_null = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(method); + _PyStackRef temp = callable; + callable = 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]); + op(_DO_CALL_KW, (callable, self_or_null, args[oparg], kwnames -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); // oparg counts all of the args, but *not* self: int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4527,7 +4521,7 @@ dummy_func( 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[0], locals, + tstate, callable, locals, arguments, positional_args, kwnames_o, frame ); DEAD(args); @@ -4578,13 +4572,13 @@ dummy_func( res = PyStackRef_FromPyObjectSteal(res_o); } - op(_PY_FRAME_KW, (callable[1], self_or_null[1], args[oparg], kwnames -- new_frame: _PyInterpreterFrame*)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + op(_PY_FRAME_KW, (callable, self_or_null, args[oparg], kwnames -- new_frame: _PyInterpreterFrame*)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4594,7 +4588,7 @@ dummy_func( 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 *temp = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, arguments, positional_args, kwnames_o, frame ); PyStackRef_CLOSE(kwnames); @@ -4608,8 +4602,8 @@ dummy_func( new_frame = temp; } - 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]); + op(_CHECK_FUNCTION_VERSION_KW, (func_version/2, callable, unused, unused[oparg], unused -- callable, unused, unused[oparg], unused)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); EXIT_IF(!PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; EXIT_IF(func->func_version != func_version); @@ -4623,24 +4617,24 @@ dummy_func( _SAVE_RETURN_OFFSET + _PUSH_FRAME; - 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]); + op(_CHECK_METHOD_VERSION_KW, (func_version/2, callable, null, unused[oparg], unused -- callable, null, unused[oparg], unused)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); EXIT_IF(Py_TYPE(callable_o) != &PyMethod_Type); PyObject *func = ((PyMethodObject *)callable_o)->im_func; EXIT_IF(!PyFunction_Check(func)); EXIT_IF(((PyFunctionObject *)func)->func_version != func_version); - EXIT_IF(!PyStackRef_IsNull(null[0])); + EXIT_IF(!PyStackRef_IsNull(null)); } - op(_EXPAND_METHOD_KW, (callable[1], self_or_null[1], unused[oparg], unused -- callable[1], self_or_null[1], unused[oparg], unused)) { - assert(PyStackRef_IsNull(self_or_null[0])); - _PyStackRef callable_s = callable[0]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s); + op(_EXPAND_METHOD_KW, (callable, self_or_null, unused[oparg], unused -- callable, self_or_null, unused[oparg], unused)) { + assert(PyStackRef_IsNull(self_or_null)); + _PyStackRef callable_s = callable; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(Py_TYPE(callable_o) == &PyMethod_Type); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(callable[0])); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(callable)); PyStackRef_CLOSE(callable_s); } @@ -4654,11 +4648,11 @@ dummy_func( _SAVE_RETURN_OFFSET + _PUSH_FRAME; - 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)) { + specializing op(_SPECIALIZE_CALL_KW, (counter/1, callable, self_or_null, unused[oparg], unused -- callable, self_or_null, unused[oparg], unused)) { #if ENABLE_SPECIALIZATION_FT if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; - _Py_Specialize_CallKw(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); + _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null)); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL_KW); @@ -4679,22 +4673,22 @@ dummy_func( _MONITOR_CALL_KW + _DO_CALL_KW; - 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]); + op(_CHECK_IS_NOT_PY_CALLABLE_KW, (callable, unused, unused[oparg], unused -- callable, unused, unused[oparg], unused)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); EXIT_IF(PyFunction_Check(callable_o)); EXIT_IF(Py_TYPE(callable_o) == &PyMethod_Type); } - op(_CALL_KW_NON_PY, (callable[1], self_or_null[1], args[oparg], kwnames -- res)) { + op(_CALL_KW_NON_PY, (callable, self_or_null, args[oparg], kwnames -- res)) { #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 9bfb13e2d9773f..e7f8d0bc5b93eb 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -615,7 +615,6 @@ _PyStackRef val; value = stack_pointer[-1]; receiver = stack_pointer[-2]; - (void)receiver; val = value; stack_pointer[-2] = val; stack_pointer += -1; @@ -4648,25 +4647,26 @@ } case _MAYBE_EXPAND_METHOD: { - _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - (void)args; - if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null[0] = PyStackRef_FromPyObjectNew(self); + self_or_null = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(method); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); } + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; break; } @@ -4676,16 +4676,16 @@ case _PY_FRAME_GENERAL: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _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[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -4694,7 +4694,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, args, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4711,11 +4711,11 @@ } 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_OPERAND0(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (!PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4741,13 +4741,13 @@ } case _CHECK_METHOD_VERSION: { - _PyStackRef *null; - _PyStackRef *callable; + _PyStackRef null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; + null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; uint32_t func_version = (uint32_t)CURRENT_OPERAND0(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (Py_TYPE(callable_o) != &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4761,7 +4761,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - if (!PyStackRef_IsNull(null[0])) { + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } @@ -4769,18 +4769,20 @@ } case _EXPAND_METHOD: { - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); - assert(PyStackRef_IsNull(self_or_null[0])); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + assert(PyStackRef_IsNull(self_or_null)); assert(Py_TYPE(callable_o) == &PyMethod_Type); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(callable[0])); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(callable)); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4788,10 +4790,10 @@ } case _CHECK_IS_NOT_PY_CALLABLE: { - _PyStackRef *callable; + _PyStackRef callable; oparg = CURRENT_OPARG(); - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4805,20 +4807,20 @@ case _CALL_NON_PY_GENERAL: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -4831,11 +4833,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -4857,11 +4861,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -4877,16 +4883,16 @@ } case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: { - _PyStackRef *null; - _PyStackRef *callable; + _PyStackRef null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - if (!PyStackRef_IsNull(null[0])) { + null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type) { + if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } @@ -4894,17 +4900,19 @@ } case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: { - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - assert(PyStackRef_IsNull(self_or_null[0])); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + assert(PyStackRef_IsNull(self_or_null)); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); STAT_INC(CALL, hit); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4920,16 +4928,16 @@ } case _CHECK_FUNCTION_EXACT_ARGS: { - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; - if (code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0]))) { + if (code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null))) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } @@ -4937,10 +4945,10 @@ } case _CHECK_STACK_SPACE: { - _PyStackRef *callable; + _PyStackRef callable; oparg = CURRENT_OPARG(); - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { @@ -4956,19 +4964,19 @@ case _INIT_CALL_PY_EXACT_ARGS_0: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _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]; - int has_self = !PyStackRef_IsNull(self_or_null[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -4980,19 +4988,19 @@ case _INIT_CALL_PY_EXACT_ARGS_1: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _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]; - int has_self = !PyStackRef_IsNull(self_or_null[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -5004,19 +5012,19 @@ case _INIT_CALL_PY_EXACT_ARGS_2: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _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]; - int has_self = !PyStackRef_IsNull(self_or_null[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -5028,19 +5036,19 @@ case _INIT_CALL_PY_EXACT_ARGS_3: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _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]; - int has_self = !PyStackRef_IsNull(self_or_null[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -5052,19 +5060,19 @@ case _INIT_CALL_PY_EXACT_ARGS_4: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _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]; - int has_self = !PyStackRef_IsNull(self_or_null[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -5076,18 +5084,18 @@ case _INIT_CALL_PY_EXACT_ARGS: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyInterpreterFrame *new_frame; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - int has_self = !PyStackRef_IsNull(self_or_null[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -5225,17 +5233,14 @@ } case _CHECK_AND_ALLOCATE_OBJECT: { - _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; uint32_t type_version = (uint32_t)CURRENT_OPERAND0(); - (void)args; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); - if (!PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (!PyStackRef_IsNull(self_or_null)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } @@ -5265,9 +5270,11 @@ if (self_o == NULL) { JUMP_TO_ERROR(); } - self_or_null[0] = PyStackRef_FromPyObjectSteal(self_o); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(init_func); + self_or_null = PyStackRef_FromPyObjectSteal(self_o); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(init_func); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5276,23 +5283,23 @@ case _CREATE_INIT_FRAME: { _PyStackRef *args; - _PyStackRef *self; - _PyStackRef *init; + _PyStackRef self; + _PyStackRef init; _PyInterpreterFrame *init_frame; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self = &stack_pointer[-1 - oparg]; - init = &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(_PyFrame_GetBytecode(shim)[0].op.code == EXIT_INIT_CHECK); assert(_PyFrame_GetBytecode(shim)[1].op.code == RETURN_VALUE); - shim->localsplus[0] = PyStackRef_DUP(self[0]); + shim->localsplus[0] = PyStackRef_DUP(self); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, init[0], NULL, args-1, oparg+1, NULL, shim); + tstate, init, NULL, args-1, oparg+1, NULL, shim); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -5329,14 +5336,14 @@ case _CALL_BUILTIN_CLASS: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (!PyType_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -5344,7 +5351,7 @@ PyTypeObject *tp = (PyTypeObject *)callable_o; int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -5362,11 +5369,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5384,11 +5393,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5405,16 +5416,16 @@ case _CALL_BUILTIN_O: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -5448,7 +5459,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) { JUMP_TO_ERROR(); @@ -5462,17 +5473,17 @@ case _CALL_BUILTIN_FAST: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -5495,11 +5506,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5521,11 +5534,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5542,17 +5557,17 @@ case _CALL_BUILTIN_FAST_WITH_KEYWORDS: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -5579,11 +5594,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5602,11 +5619,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5623,16 +5642,16 @@ case _CALL_LEN: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -5665,7 +5684,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; @@ -5676,17 +5695,17 @@ case _CALL_ISINSTANCE: { _PyStackRef *args; - _PyStackRef *self_or_null; + _PyStackRef self_or_null; _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; + self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -5720,8 +5739,9 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -1 - oparg; @@ -5783,17 +5803,17 @@ case _CALL_METHOD_DESCRIPTOR_O: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -5838,11 +5858,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5859,17 +5881,17 @@ case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -5905,11 +5927,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5930,11 +5954,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -5951,17 +5977,17 @@ case _CALL_METHOD_DESCRIPTOR_NOARGS: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; assert(oparg == 0 || oparg == 1); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -6002,7 +6028,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) { JUMP_TO_ERROR(); @@ -6016,17 +6042,17 @@ case _CALL_METHOD_DESCRIPTOR_FAST: { _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -6061,11 +6087,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -6086,11 +6114,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -6108,30 +6138,26 @@ /* _MONITOR_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ case _MAYBE_EXPAND_METHOD_KW: { - _PyStackRef kwnames_in; - _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; - _PyStackRef kwnames_out; + _PyStackRef self_or_null; + _PyStackRef callable; 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]; - (void)args; - if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null[0] = PyStackRef_FromPyObjectNew(self); + self_or_null = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(method); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); } - kwnames_out = kwnames_in; - stack_pointer[-1] = kwnames_out; + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; break; } @@ -6140,18 +6166,18 @@ case _PY_FRAME_KW: { _PyStackRef kwnames; _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _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[0]); + self_or_null = stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -6162,7 +6188,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, arguments, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6184,11 +6210,11 @@ } 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_OPERAND0(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (!PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -6202,13 +6228,13 @@ } case _CHECK_METHOD_VERSION_KW: { - _PyStackRef *null; - _PyStackRef *callable; + _PyStackRef null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - null = &stack_pointer[-2 - oparg]; - callable = &stack_pointer[-3 - oparg]; + null = stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; uint32_t func_version = (uint32_t)CURRENT_OPERAND0(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (Py_TYPE(callable_o) != &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -6222,7 +6248,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - if (!PyStackRef_IsNull(null[0])) { + if (!PyStackRef_IsNull(null)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } @@ -6230,18 +6256,20 @@ } case _EXPAND_METHOD_KW: { - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _PyStackRef callable; oparg = CURRENT_OPARG(); - self_or_null = &stack_pointer[-2 - oparg]; - callable = &stack_pointer[-3 - oparg]; - assert(PyStackRef_IsNull(self_or_null[0])); - _PyStackRef callable_s = callable[0]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s); + self_or_null = stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; + assert(PyStackRef_IsNull(self_or_null)); + _PyStackRef callable_s = callable; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(Py_TYPE(callable_o) == &PyMethod_Type); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(callable[0])); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(callable)); + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(callable_s); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6249,10 +6277,10 @@ } 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[0]); + callable = stack_pointer[-3 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -6267,21 +6295,21 @@ case _CALL_KW_NON_PY: { _PyStackRef kwnames; _PyStackRef *args; - _PyStackRef *self_or_null; - _PyStackRef *callable; + _PyStackRef self_or_null; + _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]; + self_or_null = stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -6297,11 +6325,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-2 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-3 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -3 - oparg; @@ -6330,11 +6360,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 6fe647d6197a07..fcb2ec1527405b 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1350,21 +1350,21 @@ _Py_CODEUNIT* const this_instr = next_instr - 4; (void)this_instr; opcode = CALL; - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _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_FT if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_Specialize_Call(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); + _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null)); stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } @@ -1375,15 +1375,15 @@ /* Skip 2 cache entries */ // _MAYBE_EXPAND_METHOD { - args = &stack_pointer[-oparg]; - (void)args; - if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null[0] = PyStackRef_FromPyObjectNew(self); + self_or_null = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(method); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1392,10 +1392,10 @@ // _DO_CALL { args = &stack_pointer[-oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -1405,9 +1405,11 @@ { 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[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, arguments, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1426,19 +1428,25 @@ for (int _i = oparg; --_i >= 0;) { tmp = args[_i]; args[_i] = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); JUMP_TO_LABEL(error); } + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -1477,11 +1485,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -1525,11 +1535,11 @@ next_instr += 4; INSTRUCTION_STATS(CALL_ALLOC_AND_ENTER_INIT); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; + _PyStackRef init; + _PyStackRef self; _PyStackRef *args; - _PyStackRef *init; - _PyStackRef *self; _PyInterpreterFrame *init_frame; _PyInterpreterFrame *new_frame; /* Skip 1 cache entry */ @@ -1543,13 +1553,11 @@ } // _CHECK_AND_ALLOCATE_OBJECT { - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; uint32_t type_version = read_u32(&this_instr[2].cache); - (void)args; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); - if (!PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + if (!PyStackRef_IsNull(self_or_null)) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); JUMP_TO_PREDICTED(CALL); @@ -1583,15 +1591,18 @@ if (self_o == NULL) { JUMP_TO_LABEL(error); } - self_or_null[0] = PyStackRef_FromPyObjectSteal(self_o); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(init_func); + self_or_null = PyStackRef_FromPyObjectSteal(self_o); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(init_func); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); } // _CREATE_INIT_FRAME { + args = &stack_pointer[-oparg]; self = self_or_null; init = callable; _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1600,10 +1611,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); assert(_PyFrame_GetBytecode(shim)[0].op.code == EXIT_INIT_CHECK); assert(_PyFrame_GetBytecode(shim)[1].op.code == RETURN_VALUE); - shim->localsplus[0] = PyStackRef_DUP(self[0]); + shim->localsplus[0] = PyStackRef_DUP(self); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, init[0], NULL, args-1, oparg+1, NULL, shim); + tstate, init, NULL, args-1, oparg+1, NULL, shim); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1645,9 +1656,9 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BOUND_METHOD_EXACT_ARGS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *null; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef null; + _PyStackRef self_or_null; _PyStackRef *args; _PyInterpreterFrame *new_frame; /* Skip 1 cache entry */ @@ -1661,14 +1672,14 @@ } // _CHECK_CALL_BOUND_METHOD_EXACT_ARGS { - null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - if (!PyStackRef_IsNull(null[0])) { + null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + if (!PyStackRef_IsNull(null)) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); JUMP_TO_PREDICTED(CALL); } - if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type) { + if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); JUMP_TO_PREDICTED(CALL); @@ -1677,12 +1688,14 @@ // _INIT_CALL_BOUND_METHOD_EXACT_ARGS { self_or_null = null; - assert(PyStackRef_IsNull(self_or_null[0])); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + assert(PyStackRef_IsNull(self_or_null)); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); STAT_INC(CALL, hit); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1691,7 +1704,7 @@ // _CHECK_FUNCTION_VERSION { uint32_t func_version = read_u32(&this_instr[2].cache); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (!PyFunction_Check(callable_o)) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); @@ -1706,11 +1719,11 @@ } // _CHECK_FUNCTION_EXACT_ARGS { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; - if (code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0]))) { + if (code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null))) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); JUMP_TO_PREDICTED(CALL); @@ -1718,7 +1731,7 @@ } // _CHECK_STACK_SPACE { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { @@ -1735,11 +1748,11 @@ // _INIT_CALL_PY_EXACT_ARGS { args = &stack_pointer[-oparg]; - int has_self = !PyStackRef_IsNull(self_or_null[0]); + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -1782,9 +1795,9 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BOUND_METHOD_GENERAL); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *null; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef null; + _PyStackRef self_or_null; _PyStackRef *args; _PyInterpreterFrame *new_frame; /* Skip 1 cache entry */ @@ -1798,10 +1811,10 @@ } // _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[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (Py_TYPE(callable_o) != &PyMethod_Type) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); @@ -1818,7 +1831,7 @@ assert(_PyOpcode_Deopt[opcode] == (CALL)); JUMP_TO_PREDICTED(CALL); } - if (!PyStackRef_IsNull(null[0])) { + if (!PyStackRef_IsNull(null)) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); JUMP_TO_PREDICTED(CALL); @@ -1827,13 +1840,15 @@ // _EXPAND_METHOD { self_or_null = null; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); - assert(PyStackRef_IsNull(self_or_null[0])); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + assert(PyStackRef_IsNull(self_or_null)); assert(Py_TYPE(callable_o) == &PyMethod_Type); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(callable[0])); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(callable)); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1842,9 +1857,9 @@ // _PY_FRAME_GENERAL { args = &stack_pointer[-oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -1853,7 +1868,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, args, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1900,8 +1915,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BUILTIN_CLASS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ @@ -1909,9 +1924,9 @@ // _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[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (!PyType_Check(callable_o)) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); @@ -1920,7 +1935,7 @@ PyTypeObject *tp = (PyTypeObject *)callable_o; int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -1939,11 +1954,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -1961,11 +1978,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -2009,8 +2028,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BUILTIN_FAST); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ @@ -2018,12 +2037,12 @@ // _CALL_BUILTIN_FAST { args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -2048,11 +2067,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -2074,11 +2095,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -2122,8 +2145,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BUILTIN_FAST_WITH_KEYWORDS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ @@ -2131,12 +2154,12 @@ // _CALL_BUILTIN_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[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -2165,11 +2188,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -2188,11 +2213,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -2236,8 +2263,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BUILTIN_O); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ @@ -2245,11 +2272,11 @@ // _CALL_BUILTIN_O { args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -2287,7 +2314,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) { JUMP_TO_LABEL(error); @@ -2573,18 +2600,18 @@ INSTRUCTION_STATS(CALL_ISINSTANCE); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); _PyStackRef callable; - _PyStackRef *self_or_null; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ /* Skip 2 cache entries */ args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; + self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -2620,8 +2647,9 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -1 - oparg; @@ -2641,24 +2669,22 @@ _Py_CODEUNIT* const this_instr = next_instr - 4; (void)this_instr; opcode = CALL_KW; - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; - _PyStackRef kwnames_in; - _PyStackRef kwnames_out; _PyStackRef kwnames; _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_FT if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_Specialize_CallKw(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); + _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null)); stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } @@ -2669,31 +2695,29 @@ /* Skip 2 cache entries */ // _MAYBE_EXPAND_METHOD_KW { - kwnames_in = stack_pointer[-1]; - args = &stack_pointer[-1 - oparg]; - (void)args; - if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null[0] = PyStackRef_FromPyObjectNew(self); + self_or_null = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(method); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); } - kwnames_out = kwnames_in; } // _DO_CALL_KW { - kwnames = kwnames_out; + kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -2704,10 +2728,11 @@ { 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; + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, arguments, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2728,6 +2753,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyStackRef tmp = kwnames; kwnames = PyStackRef_NULL; + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; stack_pointer[-1] = kwnames; PyStackRef_CLOSE(tmp); for (int _i = oparg; --_i >= 0;) { @@ -2735,18 +2762,21 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-2 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-3 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); JUMP_TO_LABEL(error); } - stack_pointer[-1] = kwnames; + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -2787,11 +2817,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-2 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-3 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -3 - oparg; @@ -2818,9 +2850,9 @@ next_instr += 4; INSTRUCTION_STATS(CALL_KW_BOUND_METHOD); static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *null; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef null; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef kwnames; _PyInterpreterFrame *new_frame; @@ -2835,10 +2867,10 @@ } // _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[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (Py_TYPE(callable_o) != &PyMethod_Type) { UPDATE_MISS_STATS(CALL_KW); assert(_PyOpcode_Deopt[opcode] == (CALL_KW)); @@ -2855,7 +2887,7 @@ assert(_PyOpcode_Deopt[opcode] == (CALL_KW)); JUMP_TO_PREDICTED(CALL_KW); } - if (!PyStackRef_IsNull(null[0])) { + if (!PyStackRef_IsNull(null)) { UPDATE_MISS_STATS(CALL_KW); assert(_PyOpcode_Deopt[opcode] == (CALL_KW)); JUMP_TO_PREDICTED(CALL_KW); @@ -2864,13 +2896,15 @@ // _EXPAND_METHOD_KW { self_or_null = null; - assert(PyStackRef_IsNull(self_or_null[0])); - _PyStackRef callable_s = callable[0]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s); + assert(PyStackRef_IsNull(self_or_null)); + _PyStackRef callable_s = callable; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(Py_TYPE(callable_o) == &PyMethod_Type); - self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(callable[0])); + self_or_null = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); + callable = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(callable)); + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(callable_s); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2880,10 +2914,10 @@ { kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -2894,7 +2928,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, arguments, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2947,8 +2981,8 @@ INSTRUCTION_STATS(CALL_KW_NON_PY); opcode = CALL_KW_NON_PY; static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef kwnames; _PyStackRef res; @@ -2956,8 +2990,8 @@ /* Skip 2 cache entries */ // _CHECK_IS_NOT_PY_CALLABLE_KW { - callable = &stack_pointer[-3 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + callable = stack_pointer[-3 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (PyFunction_Check(callable_o)) { UPDATE_MISS_STATS(CALL_KW); assert(_PyOpcode_Deopt[opcode] == (CALL_KW)); @@ -2973,14 +3007,14 @@ { kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; - self_or_null = &stack_pointer[-2 - oparg]; + self_or_null = stack_pointer[-2 - oparg]; #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -2996,11 +3030,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-2 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-3 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -3 - oparg; @@ -3029,11 +3065,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -3077,8 +3115,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_KW_PY); static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef kwnames; _PyInterpreterFrame *new_frame; @@ -3093,9 +3131,9 @@ } // _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[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (!PyFunction_Check(callable_o)) { UPDATE_MISS_STATS(CALL_KW); assert(_PyOpcode_Deopt[opcode] == (CALL_KW)); @@ -3112,11 +3150,11 @@ { kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; - self_or_null = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -3127,7 +3165,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, arguments, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3179,18 +3217,18 @@ next_instr += 4; INSTRUCTION_STATS(CALL_LEN); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ /* Skip 2 cache entries */ args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -3225,7 +3263,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; @@ -3312,8 +3350,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_FAST); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ @@ -3321,12 +3359,12 @@ // _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[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -3365,11 +3403,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -3390,11 +3430,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -3438,8 +3480,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ @@ -3447,12 +3489,12 @@ // _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[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -3492,11 +3534,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -3517,11 +3561,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -3565,8 +3611,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_NOARGS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ @@ -3574,12 +3620,12 @@ // _CALL_METHOD_DESCRIPTOR_NOARGS { args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; assert(oparg == 0 || oparg == 1); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -3625,7 +3671,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyStackRef_CLOSE(callable[0]); + PyStackRef_CLOSE(callable); stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) { JUMP_TO_LABEL(error); @@ -3666,8 +3712,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_O); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyStackRef res; /* Skip 1 cache entry */ @@ -3675,12 +3721,12 @@ // _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[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -3730,11 +3776,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -3779,16 +3827,16 @@ INSTRUCTION_STATS(CALL_NON_PY_GENERAL); opcode = CALL_NON_PY_GENERAL; static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _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[0]); + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (PyFunction_Check(callable_o)) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); @@ -3803,14 +3851,14 @@ // _CALL_NON_PY_GENERAL { args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; + self_or_null = stack_pointer[-1 - oparg]; #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -3823,11 +3871,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -3849,11 +3899,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -3897,8 +3949,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_PY_EXACT_ARGS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyInterpreterFrame *new_frame; /* Skip 1 cache entry */ @@ -3912,9 +3964,9 @@ } // _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[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (!PyFunction_Check(callable_o)) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); @@ -3929,12 +3981,12 @@ } // _CHECK_FUNCTION_EXACT_ARGS { - self_or_null = &stack_pointer[-1 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; - if (code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0]))) { + if (code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null))) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); JUMP_TO_PREDICTED(CALL); @@ -3942,7 +3994,7 @@ } // _CHECK_STACK_SPACE { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { @@ -3959,12 +4011,11 @@ // _INIT_CALL_PY_EXACT_ARGS { args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - int has_self = !PyStackRef_IsNull(self_or_null[0]); + int has_self = !PyStackRef_IsNull(self_or_null); STAT_INC(CALL, hit); - new_frame = _PyFrame_PushUnchecked(tstate, callable[0], oparg + has_self, frame); + new_frame = _PyFrame_PushUnchecked(tstate, callable, oparg + has_self, frame); _PyStackRef *first_non_self_local = new_frame->localsplus + has_self; - new_frame->localsplus[0] = self_or_null[0]; + new_frame->localsplus[0] = self_or_null; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } @@ -4007,8 +4058,8 @@ next_instr += 4; INSTRUCTION_STATS(CALL_PY_GENERAL); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; _PyInterpreterFrame *new_frame; /* Skip 1 cache entry */ @@ -4022,9 +4073,9 @@ } // _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[0]); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); if (!PyFunction_Check(callable_o)) { UPDATE_MISS_STATS(CALL); assert(_PyOpcode_Deopt[opcode] == (CALL)); @@ -4040,10 +4091,10 @@ // _PY_FRAME_GENERAL { args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { args--; total_args++; } @@ -4052,7 +4103,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( - tstate, callable[0], locals, + tstate, callable, locals, args, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5264,7 +5315,6 @@ _PyStackRef val; value = stack_pointer[-1]; receiver = stack_pointer[-2]; - (void)receiver; val = value; stack_pointer[-2] = val; stack_pointer += -1; @@ -6086,26 +6136,26 @@ next_instr += 4; INSTRUCTION_STATS(INSTRUMENTED_CALL); opcode = INSTRUMENTED_CALL; - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; + _PyStackRef func; + _PyStackRef maybe_self; _PyStackRef *args; - _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]; - (void)args; - if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null[0] = PyStackRef_FromPyObjectNew(self); + self_or_null = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(method); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6113,13 +6163,14 @@ } // _MONITOR_CALL { + args = &stack_pointer[-oparg]; maybe_self = self_or_null; func = callable; - int is_meth = !PyStackRef_IsNull(maybe_self[0]); - PyObject *function = PyStackRef_AsPyObjectBorrow(func[0]); + int is_meth = !PyStackRef_IsNull(maybe_self); + PyObject *function = PyStackRef_AsPyObjectBorrow(func); PyObject *arg0; if (is_meth) { - arg0 = PyStackRef_AsPyObjectBorrow(maybe_self[0]); + arg0 = PyStackRef_AsPyObjectBorrow(maybe_self); } else if (oparg) { arg0 = PyStackRef_AsPyObjectBorrow(args[0]); @@ -6127,6 +6178,8 @@ else { arg0 = &_PyInstrumentation_MISSING; } + stack_pointer[-2 - oparg] = func; + stack_pointer[-1 - oparg] = maybe_self; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -6140,12 +6193,12 @@ // _DO_CALL { args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -6157,7 +6210,7 @@ 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[0], locals, + tstate, callable, locals, arguments, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6178,11 +6231,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -6227,11 +6282,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-1 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-2 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -2 - oparg; @@ -6450,41 +6507,38 @@ next_instr += 4; INSTRUCTION_STATS(INSTRUMENTED_CALL_KW); opcode = INSTRUMENTED_CALL_KW; - _PyStackRef *callable; - _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef self_or_null; _PyStackRef *args; - _PyStackRef kwnames_in; - _PyStackRef kwnames_out; _PyStackRef kwnames; _PyStackRef res; /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _MAYBE_EXPAND_METHOD_KW { - kwnames_in = stack_pointer[-1]; - args = &stack_pointer[-1 - oparg]; - self_or_null = &stack_pointer[-2 - oparg]; - callable = &stack_pointer[-3 - oparg]; - (void)args; - if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + self_or_null = stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self = ((PyMethodObject *)callable_o)->im_self; - self_or_null[0] = PyStackRef_FromPyObjectNew(self); + self_or_null = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - _PyStackRef temp = callable[0]; - callable[0] = PyStackRef_FromPyObjectNew(method); + _PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_CLOSE(temp); stack_pointer = _PyFrame_GetStackPointer(frame); } - kwnames_out = kwnames_in; } // _MONITOR_CALL_KW { - int is_meth = !PyStackRef_IsNull(self_or_null[0]); + args = &stack_pointer[-1 - oparg]; + int is_meth = !PyStackRef_IsNull(self_or_null); PyObject *arg; if (is_meth) { - arg = PyStackRef_AsPyObjectBorrow(self_or_null[0]); + arg = PyStackRef_AsPyObjectBorrow(self_or_null); } else if (args) { arg = PyStackRef_AsPyObjectBorrow(args[0]); @@ -6492,8 +6546,9 @@ else { arg = &_PyInstrumentation_MISSING; } - PyObject *function = PyStackRef_AsPyObjectBorrow(callable[0]); - stack_pointer[-1] = kwnames_out; + PyObject *function = PyStackRef_AsPyObjectBorrow(callable); + stack_pointer[-3 - oparg] = callable; + stack_pointer[-2 - oparg] = self_or_null; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -6505,12 +6560,13 @@ } // _DO_CALL_KW { - kwnames = kwnames_out; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + kwnames = stack_pointer[-1]; + args = &stack_pointer[-1 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); int total_args = oparg; _PyStackRef *arguments = args; - if (!PyStackRef_IsNull(self_or_null[0])) { + if (!PyStackRef_IsNull(self_or_null)) { arguments--; total_args++; } @@ -6523,7 +6579,7 @@ 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[0], locals, + tstate, callable, locals, arguments, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6551,11 +6607,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-2 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-3 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -3 - oparg; @@ -6602,11 +6660,13 @@ args[_i] = PyStackRef_NULL; PyStackRef_CLOSE(tmp); } - tmp = self_or_null[0]; - self_or_null[0] = PyStackRef_NULL; + tmp = self_or_null; + self_or_null = PyStackRef_NULL; + stack_pointer[-2 - oparg] = self_or_null; PyStackRef_XCLOSE(tmp); - tmp = callable[0]; - callable[0] = PyStackRef_NULL; + tmp = callable; + callable = PyStackRef_NULL; + stack_pointer[-3 - oparg] = callable; PyStackRef_CLOSE(tmp); stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer += -3 - oparg; diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index 8e1eacfec83e95..8531c6a786cc4e 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -534,10 +534,10 @@ dummy_func(void) { top = bottom; } - op(_SWAP, (bottom[1], unused[oparg-2], top[1] -- bottom[1], unused[oparg-2], top[1])) { - JitOptSymbol *temp = bottom[0]; - bottom[0] = top[0]; - top[0] = temp; + op(_SWAP, (bottom, unused[oparg-2], top -- bottom, unused[oparg-2], top)) { + JitOptSymbol *temp = bottom; + bottom = top; + top = temp; assert(oparg >= 2); } @@ -546,7 +546,7 @@ dummy_func(void) { (void)offset; } - op(_LOAD_ATTR_MODULE, (dict_version/2, owner, index/1 -- attr)) { + op(_LOAD_ATTR_MODULE, (dict_version/2, index/1, owner -- attr)) { (void)dict_version; (void)index; attr = NULL; @@ -626,9 +626,9 @@ dummy_func(void) { ctx->done = true; } - op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) { - callable[0] = sym_new_not_null(ctx); - self_or_null[0] = sym_new_not_null(ctx); + op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { + callable = sym_new_not_null(ctx); + self_or_null = sym_new_not_null(ctx); } op(_CHECK_FUNCTION_VERSION, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 6a20cef906242b..c87009cba229a2 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -1742,12 +1742,14 @@ } case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: { - JitOptSymbol **self_or_null; - JitOptSymbol **callable; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - callable[0] = sym_new_not_null(ctx); - self_or_null[0] = sym_new_not_null(ctx); + JitOptSymbol *self_or_null; + JitOptSymbol *callable; + self_or_null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; + callable = sym_new_not_null(ctx); + self_or_null = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = callable; + stack_pointer[-1 - oparg] = self_or_null; break; } @@ -2003,9 +2005,6 @@ /* _MONITOR_CALL_KW is not a viable micro-op for tier 2 */ case _MAYBE_EXPAND_METHOD_KW: { - JitOptSymbol *kwnames_out; - kwnames_out = sym_new_not_null(ctx); - stack_pointer[-1] = kwnames_out; break; } @@ -2180,14 +2179,16 @@ } case _SWAP: { - JitOptSymbol **top; - JitOptSymbol **bottom; - top = &stack_pointer[-1]; - bottom = &stack_pointer[-2 - (oparg-2)]; - JitOptSymbol *temp = bottom[0]; - bottom[0] = top[0]; - top[0] = temp; + JitOptSymbol *top; + JitOptSymbol *bottom; + top = stack_pointer[-1]; + bottom = stack_pointer[-2 - (oparg-2)]; + JitOptSymbol *temp = bottom; + bottom = top; + top = temp; assert(oparg >= 2); + stack_pointer[-2 - (oparg-2)] = bottom; + stack_pointer[-1] = top; break; } diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index ff1e2ea74dbab8..6b681775f48c81 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -572,23 +572,21 @@ def copy(self) -> "Storage": self.check_liveness, self.spilled ) - def sanity_check(self) -> None: + @staticmethod + def check_names(locals: list[Local]) -> 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: + for var in locals: + if var.name == "unused": + continue if var.name in names: raise StackError(f"Duplicate name {var.name}") names.add(var.name) + def sanity_check(self) -> None: + self.check_names(self.inputs) + self.check_names(self.outputs) + self.check_names(self.stack.variables) + def is_flushed(self) -> bool: for var in self.outputs: if var.in_local and not var.memory_offset: