bpo-36974: separate vectorcall functions for each calling convention

Author: jdemeyer

Include/descrobject.h

@@ -91,9 +91,6 @@ PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *,
 PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
                                                struct PyGetSetDef *);
 #ifndef Py_LIMITED_API
-
-PyAPI_FUNC(PyObject *) _PyMethodDescr_Vectorcall(
-        PyObject *descrobj, PyObject *const *args, size_t nargsf, PyObject *kwnames);
 PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *,
                                                 struct wrapperbase *, void *);
 #define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL)

Include/methodobject.h

@@ -41,11 +41,15 @@ PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject *);
 #endif
 PyAPI_FUNC(PyObject *) PyCFunction_Call(PyObject *, PyObject *, PyObject *);
 
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _PyCFunction_Vectorcall(PyObject *func,
-    PyObject *const *stack,
-    size_t nargsf,
-    PyObject *kwnames);
+#ifdef Py_BUILD_CORE
+extern PyObject * _PyCFunction_Vectorcall_FASTCALL(
+    PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+extern PyObject * _PyCFunction_Vectorcall_FASTCALL_KEYWORDS(
+    PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+extern PyObject * _PyCFunction_Vectorcall_NOARGS(
+    PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
+extern PyObject * _PyCFunction_Vectorcall_O(
+    PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
 #endif
 
 struct PyMethodDef {

Lib/test/test_gdb.py

@@ -871,10 +871,10 @@ def test_pycfunction(self):
         # called, so test a variety of calling conventions.
         for py_name, py_args, c_name, expected_frame_number in (
             ('gmtime', '', 'time_gmtime', 1),  # METH_VARARGS
-            ('len', '[]', 'builtin_len', 2),  # METH_O
-            ('locals', '', 'builtin_locals', 2),  # METH_NOARGS
-            ('iter', '[]', 'builtin_iter', 2),  # METH_FASTCALL
-            ('sorted', '[]', 'builtin_sorted', 2),  # METH_FASTCALL|METH_KEYWORDS
+            ('len', '[]', 'builtin_len', 1),  # METH_O
+            ('locals', '', 'builtin_locals', 1),  # METH_NOARGS
+            ('iter', '[]', 'builtin_iter', 1),  # METH_FASTCALL
+            ('sorted', '[]', 'builtin_sorted', 1),  # METH_FASTCALL|METH_KEYWORDS
         ):
             with self.subTest(c_name):
                 cmd = ('from time import gmtime\n'  # (not always needed)

Misc/NEWS.d/next/Core and Builtins/2019-06-11-12-59-38.bpo-36974.bVYmSA.rst

@@ -0,0 +1,2 @@
+Implemented separate vectorcall functions for every calling convention of
+builtin functions and methods. This improves performance for calls.

Objects/call.c

@@ -625,22 +625,83 @@ _PyMethodDef_RawFastCallKeywords(PyMethodDef *method, PyObject *self,
 }
 
 
+/* Vectorcall functions for each of the PyCFunction calling conventions,
+ * except for METH_VARARGS (possibly combined with METH_KEYWORDS) which
+ * doesn't use vectorcall.
+ *
+ * First two macros to define common boilerplate
+ */
+#define PyCFunction_VECTORCALL_BEGIN(ALLOW_KWARGS) \
+    assert(!PyErr_Occurred()); \
+    assert(PyCFunction_Check(func)); \
+    PyCFunctionObject *f = (PyCFunctionObject *)func; \
+    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); \
+    PyObject *self = f->m_self; \
+    PyMethodDef *method = f->m_ml; \
+    const char *name = method->ml_name; \
+    void(*meth)(void) = (void(*)(void))method->ml_meth; \
+    PyObject *result = NULL; \
+    \
+    if (!ALLOW_KWARGS && kwnames && PyTuple_GET_SIZE(kwnames) > 0) { \
+        PyErr_Format(PyExc_TypeError, \
+                     "%.200s() takes no keyword arguments", name); \
+        return NULL; \
+    } \
+    if (Py_EnterRecursiveCall(" while calling a Python object")) { \
+        return NULL; \
+    }
+
+#define PyCFunction_VECTORCALL_END \
+    Py_LeaveRecursiveCall(); \
+    return _Py_CheckFunctionResult(func, result, NULL);
+
+/* Now the actual vectorcall functions */
 PyObject *
-_PyCFunction_Vectorcall(PyObject *func,
-                        PyObject *const *args, size_t nargsf,
-                        PyObject *kwnames)
+_PyCFunction_Vectorcall_FASTCALL(
+    PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
 {
-    PyObject *result;
+    PyCFunction_VECTORCALL_BEGIN(0)
+    result = ((_PyCFunctionFast)meth)(self, args, nargs);
+    PyCFunction_VECTORCALL_END
+}
 
-    assert(func != NULL);
-    assert(PyCFunction_Check(func));
-    Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
+PyObject *
+_PyCFunction_Vectorcall_FASTCALL_KEYWORDS(
+    PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    PyCFunction_VECTORCALL_BEGIN(1)
+    result = ((_PyCFunctionFastWithKeywords)meth)(self, args, nargs, kwnames);
+    PyCFunction_VECTORCALL_END
+}
 
-    result = _PyMethodDef_RawFastCallKeywords(((PyCFunctionObject*)func)->m_ml,
-                                              PyCFunction_GET_SELF(func),
-                                              args, nargs, kwnames);
-    result = _Py_CheckFunctionResult(func, result, NULL);
-    return result;
+PyObject *
+_PyCFunction_Vectorcall_NOARGS(
+    PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    PyCFunction_VECTORCALL_BEGIN(0)
+    if (nargs != 0) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes no arguments (%zd given)", name, nargs);
+    }
+    else {
+        result = ((PyCFunction)meth)(self, NULL);
+    }
+    PyCFunction_VECTORCALL_END
+}
+
+PyObject *
+_PyCFunction_Vectorcall_O(
+    PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
+{
+    PyCFunction_VECTORCALL_BEGIN(0)
+    if (nargs != 1) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s() takes exactly one argument (%zd given)", name, nargs);
+    }
+    else {
+        result = ((PyCFunction)meth)(self, args[0]);
+    }
+    PyCFunction_VECTORCALL_END
 }