Merge branch master into master-slp.

Issue python#29263: LOAD_METHOD support for C methods
The outcome of this merge is not fully functional.

Author: Anselm Kruis

Include/descrobject.h

@@ -96,6 +96,9 @@ PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *,
 PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *,
                                                struct PyGetSetDef *);
 #ifndef Py_LIMITED_API
+
+PyAPI_FUNC(PyObject *) _PyMethodDescr_FastCallKeywords(
+        PyObject *descrobj, PyObject **stack, Py_ssize_t nargs, 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

@@ -110,6 +110,13 @@ PyAPI_FUNC(PyObject *) _PyMethodDef_RawFastCallDict(
     PyObject **args,
     Py_ssize_t nargs,
     PyObject *kwargs);
+
+PyAPI_FUNC(PyObject *) _PyMethodDef_RawFastCallKeywords(
+    PyMethodDef *method,
+    PyObject *self,
+    PyObject **args,
+    Py_ssize_t nargs,
+    PyObject *kwnames);
 #endif
 
 PyAPI_FUNC(int) PyCFunction_ClearFreeList(void);

Lib/test/test_gdb.py

@@ -846,7 +846,7 @@ def test_pycfunction(self):
                                           breakpoint='time_gmtime',
                                           cmds_after_breakpoint=['py-bt-full'],
                                           )
-        self.assertIn('#1 <built-in method gmtime', gdb_output)
+        self.assertIn('#2 <built-in method gmtime', gdb_output)
 
     @unittest.skipIf(python_is_optimized(),
                      "Python was compiled with optimizations")

Objects/descrobject.c

@@ -250,6 +250,44 @@ methoddescr_call(PyMethodDescrObject *descr, PyObject *args, PyObject *kwargs)
     return result;
 }
 
+// same to methoddescr_call(), but use FASTCALL convention.
+PyObject *
+_PyMethodDescr_FastCallKeywords(PyObject *descrobj,
+                                PyObject **args, Py_ssize_t nargs,
+                                PyObject *kwnames)
+{
+    assert(Py_TYPE(descrobj) == &PyMethodDescr_Type);
+    PyMethodDescrObject *descr = (PyMethodDescrObject *)descrobj;
+    PyObject *self, *result;
+
+    /* Make sure that the first argument is acceptable as 'self' */
+    if (nargs < 1) {
+        PyErr_Format(PyExc_TypeError,
+                     "descriptor '%V' of '%.100s' "
+                     "object needs an argument",
+                     descr_name((PyDescrObject *)descr), "?",
+                     PyDescr_TYPE(descr)->tp_name);
+        return NULL;
+    }
+    self = args[0];
+    if (!_PyObject_RealIsSubclass((PyObject *)Py_TYPE(self),
+                                  (PyObject *)PyDescr_TYPE(descr))) {
+        PyErr_Format(PyExc_TypeError,
+                     "descriptor '%V' "
+                     "requires a '%.100s' object "
+                     "but received a '%.100s'",
+                     descr_name((PyDescrObject *)descr), "?",
+                     PyDescr_TYPE(descr)->tp_name,
+                     self->ob_type->tp_name);
+        return NULL;
+    }
+
+    result = _PyMethodDef_RawFastCallKeywords(descr->d_method, self,
+                                              args+1, nargs-1, kwnames);
+    result = _Py_CheckFunctionResult((PyObject *)descr, result, NULL);
+    return result;
+}
+
 static PyObject *
 classmethoddescr_call(PyMethodDescrObject *descr, PyObject *args,
                       PyObject *kwds)

Objects/methodobject.c

@@ -222,71 +222,63 @@ _PyCFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs,
 }
 
 PyObject *
-_PyCFunction_FastCallKeywords(PyObject *func_obj, PyObject **args,
-                              Py_ssize_t nargs, PyObject *kwnames)
+_PyMethodDef_RawFastCallKeywords(PyMethodDef *method, PyObject *self, PyObject **args,
+                                 Py_ssize_t nargs, PyObject *kwnames)
 {
     STACKLESS_GETARG();
-    PyCFunctionObject *func;
-    PyCFunction meth;
-    PyObject *self, *result;
-    Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
-    int flags;
+    /* _PyMethodDef_RawFastCallKeywords() must not be called with an exception set,
+       because it can clear it (directly or indirectly) and so the
+       caller loses its exception */
+    assert(!PyErr_Occurred());
 
-    assert(func_obj != NULL);
-    assert(PyCFunction_Check(func_obj));
+    assert(method != NULL);
     assert(nargs >= 0);
     assert(kwnames == NULL || PyTuple_CheckExact(kwnames));
-    assert((nargs == 0 && nkwargs == 0) || args != NULL);
     /* kwnames must only contains str strings, no subclass, and all keys must
        be unique */
 
-    /* _PyCFunction_FastCallKeywords() must not be called with an exception
-       set, because it can clear it (directly or indirectly) and so the caller
-       loses its exception */
-    assert(!PyErr_Occurred());
-
-    func = (PyCFunctionObject*)func_obj;
-    meth = PyCFunction_GET_FUNCTION(func);
-    self = PyCFunction_GET_SELF(func);
-    flags = PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
+    PyCFunction meth = method->ml_meth;
+    int flags = method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS);
+    Py_ssize_t nkwargs = kwnames == NULL ? 0 : PyTuple_Size(kwnames);
+    PyObject *result;
 
     switch (flags)
     {
     case METH_NOARGS:
         if (nargs != 0) {
             PyErr_Format(PyExc_TypeError,
                 "%.200s() takes no arguments (%zd given)",
-                func->m_ml->ml_name, nargs);
+                method->ml_name, nargs);
             return NULL;
         }
 
         if (nkwargs) {
             goto no_keyword_error;
         }
 
-        STACKLESS_PROMOTE_FLAG(PyCFunction_GET_FLAGS(func) & METH_STACKLESS);
+        STACKLESS_PROMOTE_FLAG(method->ml_flags & METH_STACKLESS);
         result = (*meth) (self, NULL);
         break;
 
     case METH_O:
         if (nargs != 1) {
             PyErr_Format(PyExc_TypeError,
                 "%.200s() takes exactly one argument (%zd given)",
-                func->m_ml->ml_name, nargs);
+                method->ml_name, nargs);
             return NULL;
         }
 
         if (nkwargs) {
             goto no_keyword_error;
         }
 
-        STACKLESS_PROMOTE_FLAG(PyCFunction_GET_FLAGS(func) & METH_STACKLESS);
+        STACKLESS_PROMOTE_FLAG(method->ml_flags & METH_STACKLESS);
         result = (*meth) (self, args[0]);
         break;
 
     case METH_FASTCALL:
         /* Fast-path: avoid temporary dict to pass keyword arguments */
-        STACKLESS_PROMOTE_FLAG(PyCFunction_GET_FLAGS(func) & METH_STACKLESS);
+        STACKLESS_PROMOTE_FLAG(method->ml_flags & METH_STACKLESS);
         result = ((_PyCFunctionFast)meth) (self, args, nargs, kwnames);
         break;
 
@@ -320,12 +312,12 @@ _PyCFunction_FastCallKeywords(PyObject *func_obj, PyObject **args,
                 kwdict = NULL;
             }
 
-            STACKLESS_PROMOTE_FLAG(PyCFunction_GET_FLAGS(func) & METH_STACKLESS);
+            STACKLESS_PROMOTE_FLAG(method->ml_flags & METH_STACKLESS);
             result = (*(PyCFunctionWithKeywords)meth) (self, argtuple, kwdict);
             Py_XDECREF(kwdict);
         }
         else {
-            STACKLESS_PROMOTE_FLAG(PyCFunction_GET_FLAGS(func) & METH_STACKLESS);
+            STACKLESS_PROMOTE_FLAG(method->ml_flags & METH_STACKLESS);
             result = (*meth) (self, argtuple);
         }
         Py_DECREF(argtuple);
@@ -340,16 +332,31 @@ _PyCFunction_FastCallKeywords(PyObject *func_obj, PyObject **args,
     }
     STACKLESS_ASSERT();
 
-    result = _Py_CheckFunctionResult(func_obj, result, NULL);
     return result;
 
 no_keyword_error:
     PyErr_Format(PyExc_TypeError,
                  "%.200s() takes no keyword arguments",
-                 func->m_ml->ml_name);
+                 method->ml_name);
     return NULL;
 }
 
+PyObject *
+_PyCFunction_FastCallKeywords(PyObject *func, PyObject **args,
+                              Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *result;
+
+    assert(func != NULL);
+    assert(PyCFunction_Check(func));
+
+    result = _PyMethodDef_RawFastCallKeywords(((PyCFunctionObject*)func)->m_ml,
+                                              PyCFunction_GET_SELF(func),
+                                              args, nargs, kwnames);
+    result = _Py_CheckFunctionResult(func, result, NULL);
+    return result;
+}
+
 /* Methods (the standard built-in methods, that is) */
 
 static void

Objects/object.c

@@ -1063,8 +1063,8 @@ _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method)
     descr = _PyType_Lookup(tp, name);
     if (descr != NULL) {
         Py_INCREF(descr);
-        if (PyFunction_Check(descr)) {
-            /* A python method. */
+        if (PyFunction_Check(descr) ||
+                (Py_TYPE(descr) == &PyMethodDescr_Type)) {
             meth_found = 1;
         } else {
             f = descr->ob_type->tp_descr_get;

Python/ceval.c

@@ -5351,19 +5351,23 @@ call_function(PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames)
     PyObject *x, *w;
     Py_ssize_t nkwargs = (kwnames == NULL) ? 0 : PyTuple_GET_SIZE(kwnames);
     Py_ssize_t nargs = oparg - nkwargs;
-    PyObject **stack;
+    PyObject **stack = (*pp_stack) - nargs - nkwargs;
 
     /* Always dispatch PyCFunction first, because these are
        presumed to be the most frequent callable object.
     */
     if (PyCFunction_Check(func)) {
         PyThreadState *tstate = PyThreadState_GET();
-
-        stack = (*pp_stack) - nargs - nkwargs;
         STACKLESS_PROPOSE_ALL();
         C_TRACE(x, _PyCFunction_FastCallKeywords(func, stack, nargs, kwnames));
         STACKLESS_ASSERT();
     }
+    else if (Py_TYPE(func) == &PyMethodDescr_Type) {
+        PyThreadState *tstate = PyThreadState_GET();
+        STACKLESS_PROPOSE_ALL();
+        C_TRACE(x, _PyMethodDescr_FastCallKeywords(func, stack, nargs, kwnames));
+        STACKLESS_ASSERT();
+    }
     else {
         if (PyMethod_Check(func) && PyMethod_GET_SELF(func) != NULL) {
             /* Optimize access to bound methods. Reuse the Python stack
@@ -5377,13 +5381,12 @@ call_function(PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames)
             Py_INCREF(func);
             Py_SETREF(*pfunc, self);
             nargs++;
+            stack--;
         }
         else {
             Py_INCREF(func);
         }
 
-        stack = (*pp_stack) - nargs - nkwargs;
-
         STACKLESS_PROPOSE_ALL();
         if (PyFunction_Check(func)) {
             x = fast_function(func, stack, nargs, kwnames);
@@ -5392,7 +5395,6 @@ call_function(PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames)
             x = _PyObject_FastCallKeywords(func, stack, nargs, kwnames);
         }
         STACKLESS_ASSERT();
-
         Py_DECREF(func);
     }
 

Tools/gdb/libpython.py

@@ -1554,10 +1554,7 @@ def is_other_python_frame(self):
 
         if caller in ('_PyCFunction_FastCallDict',
                       '_PyCFunction_FastCallKeywords'):
-            if caller == '_PyCFunction_FastCallKeywords':
-                arg_name = 'func_obj'
-            else:
-                arg_name = 'func'
+            arg_name = 'func'
             # Within that frame:
             #   "func" is the local containing the PyObject* of the
             # PyCFunctionObject instance