cleanup

Author: kumaraditya303

Include/internal/pycore_ceval.h

@@ -456,15 +456,15 @@ _Py_BuiltinCallFastWithKeywords_StackRefSteal(
 PyAPI_FUNC(PyObject *)
 _PyCallMethodDescriptorFast_StackRefSteal(
     _PyStackRef callable,
-    PyCFunction cfunc,
+    PyCFunctionFast cfunc,
     PyObject *self,
     _PyStackRef *arguments,
     int total_args);
 
 PyAPI_FUNC(PyObject *)
 _PyCallMethodDescriptorFastWithKeywords_StackRefSteal(
     _PyStackRef callable,
-    PyCFunction cfunc,
+    PyCFunctionFastWithKeywords cfunc,
     PyObject *self,
     _PyStackRef *arguments,
     int total_args);

Modules/_testinternalcapi/test_cases.c.h

@@ -4733,29 +4733,22 @@ dummy_func(
             res = PyStackRef_FromPyObjectSteal(res_o);
         }
 
-        // The optimizer folds self_or_null into args by emitting with
-        // oparg = original_oparg + 1. Total args is always 2 for METH_O,
-        // so arguments = args + oparg - 2.
         tier2 op(_CALL_METHOD_DESCRIPTOR_O_INLINE, (callable, args[oparg], cfunc/4 -- res, c, s, a)) {
-            assert(oparg >= 2);
-            _PyStackRef *arguments = args + oparg - 2;
-            // CPython promises to check all non-vectorcall function calls.
+            assert(oparg == 2);
             EXIT_IF(_Py_ReachedRecursionLimit(tstate));
-            _PyStackRef self_stackref = arguments[0];
-            _PyStackRef arg_stackref = arguments[1];
             STAT_INC(CALL, hit);
-            PyCFunction volatile cfunc_fn = (PyCFunction)cfunc;
-            PyObject *res_o = cfunc_fn(
-                                  PyStackRef_AsPyObjectBorrow(self_stackref),
-                                  PyStackRef_AsPyObjectBorrow(arg_stackref));
+            PyObject *res_o = _PyCFunction_TrampolineCall(
+                                  (PyCFunction)cfunc,
+                                  PyStackRef_AsPyObjectBorrow(args[0]),
+                                  PyStackRef_AsPyObjectBorrow(args[1]));
             _Py_LeaveRecursiveCallTstate(tstate);
             assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
             if (res_o == NULL) {
                 ERROR_NO_POP();
             }
             c = callable;
-            s = arguments[0];
-            a = arguments[1];
+            s = args[0];
+            a = args[1];
             INPUTS_DEAD();
             res = PyStackRef_FromPyObjectSteal(res_o);
         }
@@ -4800,7 +4793,7 @@ dummy_func(
             PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]);
             assert(self != NULL);
             STAT_INC(CALL, hit);
-            PyCFunction cfunc = method->d_method->ml_meth;
+            PyCFunctionFastWithKeywords cfunc = (PyCFunctionFastWithKeywords)method->d_method->ml_meth;
             PyObject *res_o = _PyCallMethodDescriptorFastWithKeywords_StackRefSteal(
                 callable,
                 cfunc,
@@ -4815,19 +4808,16 @@ dummy_func(
             res = PyStackRef_FromPyObjectSteal(res_o);
         }
 
-        // The optimizer folds self_or_null into args (oparg = original + 1)
-        // and encodes total_args in operand1 to avoid runtime null checks.
-        tier2 op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE, (callable, args[oparg], cfunc/4, total_args/2 -- res)) {
-            _PyStackRef *arguments = args + oparg - total_args;
-            PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]);
+        tier2 op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS_INLINE, (callable, args[oparg], cfunc/4 -- res)) {
+            PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]);
             assert(self != NULL);
             STAT_INC(CALL, hit);
             PyObject *res_o = _PyCallMethodDescriptorFastWithKeywords_StackRefSteal(
                 callable,
-                (PyCFunction)cfunc,
+                (PyCFunctionFastWithKeywords)cfunc,
                 self,
-                arguments,
-                total_args
+                args,
+                oparg
             );
             DEAD(args);
             DEAD(callable);
@@ -4883,21 +4873,13 @@ dummy_func(
             res = PyStackRef_FromPyObjectSteal(res_o);
         }
 
-        // The optimizer folds self_or_null into args by emitting with
-        // oparg = original_oparg + 1, so args always includes self.
-        // Self is always the last element: args[oparg - 1].
         tier2 op(_CALL_METHOD_DESCRIPTOR_NOARGS_INLINE, (callable, args[oparg], cfunc/4 -- res)) {
-            assert(oparg >= 1);
-            _PyStackRef self_stackref = args[oparg - 1];
+            assert(oparg == 1);
+            _PyStackRef self_stackref = args[0];
             PyObject *self = PyStackRef_AsPyObjectBorrow(self_stackref);
-            // CPython promises to check all non-vectorcall function calls.
             EXIT_IF(_Py_ReachedRecursionLimit(tstate));
             STAT_INC(CALL, hit);
-            // Use volatile to prevent the JIT compiler from generating a
-            // direct BL to the cfunc symbol; we need an indirect BLR since
-            // the cfunc address may be out of range for relative branches.
-            PyCFunction volatile cfunc_fn = (PyCFunction)cfunc;
-            PyObject *res_o = cfunc_fn(self, NULL);
+            PyObject *res_o = _PyCFunction_TrampolineCall((PyCFunction)cfunc, self, NULL);
             _Py_LeaveRecursiveCallTstate(tstate);
             assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
             PyStackRef_CLOSE(self_stackref);
@@ -4944,7 +4926,7 @@ dummy_func(
             PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]);
             assert(self != NULL);
             STAT_INC(CALL, hit);
-            PyCFunction cfunc = method->d_method->ml_meth;
+            PyCFunctionFast cfunc = (PyCFunctionFast)method->d_method->ml_meth;
             PyObject *res_o = _PyCallMethodDescriptorFast_StackRefSteal(
                 callable,
                 cfunc,
@@ -4959,19 +4941,16 @@ dummy_func(
             res = PyStackRef_FromPyObjectSteal(res_o);
         }
 
-        // The optimizer folds self_or_null into args (oparg = original + 1)
-        // and encodes total_args in operand1 to avoid runtime null checks.
-        tier2 op(_CALL_METHOD_DESCRIPTOR_FAST_INLINE, (callable, args[oparg], cfunc/4, total_args/2 -- res)) {
-            _PyStackRef *arguments = args + oparg - total_args;
-            PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]);
+        tier2 op(_CALL_METHOD_DESCRIPTOR_FAST_INLINE, (callable, args[oparg], cfunc/4 -- res)) {
+            PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]);
             assert(self != NULL);
             STAT_INC(CALL, hit);
             PyObject *res_o = _PyCallMethodDescriptorFast_StackRefSteal(
                 callable,
-                (PyCFunction)cfunc,
+                (PyCFunctionFast)cfunc,
                 self,
-                arguments,
-                total_args
+                args,
+                oparg
             );
             DEAD(args);
             DEAD(callable);

Python/bytecodes.c

@@ -874,7 +874,7 @@ _Py_BuiltinCallFastWithKeywords_StackRefSteal(
 PyObject *
 _PyCallMethodDescriptorFast_StackRefSteal(
     _PyStackRef callable,
-    PyCFunction cfunc,
+    PyCFunctionFast cfunc,
     PyObject *self,
     _PyStackRef *arguments,
     int total_args)
@@ -887,8 +887,7 @@ _PyCallMethodDescriptorFast_StackRefSteal(
     }
     assert(self == PyStackRef_AsPyObjectBorrow(arguments[0]));
 
-    PyCFunctionFast cfunc_fast = _PyCFunctionFast_CAST(cfunc);
-    res = cfunc_fast(self, (args_o + 1), total_args - 1);
+    res = cfunc(self, (args_o + 1), total_args - 1);
     STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
     assert((res != NULL) ^ (PyErr_Occurred() != NULL));
 cleanup:
@@ -906,7 +905,7 @@ _PyCallMethodDescriptorFast_StackRefSteal(
 PyObject *
 _PyCallMethodDescriptorFastWithKeywords_StackRefSteal(
     _PyStackRef callable,
-    PyCFunction cfunc,
+    PyCFunctionFastWithKeywords cfunc,
     PyObject *self,
     _PyStackRef *arguments,
     int total_args)
@@ -919,9 +918,7 @@ _PyCallMethodDescriptorFastWithKeywords_StackRefSteal(
     }
     assert(self == PyStackRef_AsPyObjectBorrow(arguments[0]));
 
-    PyCFunctionFastWithKeywords cfunc_kw =
-        _PyCFunctionFastWithKeywords_CAST(cfunc);
-    res = cfunc_kw(self, (args_o + 1), total_args-1, NULL);
+    res = cfunc(self, (args_o + 1), total_args-1, NULL);
     STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
     assert((res != NULL) ^ (PyErr_Occurred() != NULL));
 cleanup: