From e90bdb19f22655b8ddad32006740c55d49237748 Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Thu, 25 Aug 2016 23:26:50 +0200 Subject: Issue #27830: Revert, remove _PyFunction_FastCallKeywords() --- Include/abstract.h | 17 ----------------- Include/funcobject.h | 6 ------ Objects/abstract.c | 45 --------------------------------------------- Python/ceval.c | 12 ++++++------ 4 files changed, 6 insertions(+), 74 deletions(-) diff --git a/Include/abstract.h b/Include/abstract.h index ebad84b..f838b50 100644 --- a/Include/abstract.h +++ b/Include/abstract.h @@ -292,23 +292,6 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/ #define _PyObject_CallArg1(func, arg) \ _PyObject_FastCall((func), &(arg), 1) - /* Call the callable object func with the "fast call" calling convention: - args is a C array for positional arguments followed by (key, value) - pairs for keyword arguments. - - nargs is the number of positional parameters at the beginning of stack. - nkwargs is the number of (key, value) pairs at the end of stack. - - If nargs and nkwargs are equal to zero, stack can be NULL. - - Return the result on success. Raise an exception and return NULL on - error. */ - PyAPI_FUNC(PyObject *) _PyObject_FastCallKeywords( - PyObject *func, - PyObject **stack, - Py_ssize_t nargs, - Py_ssize_t nkwargs); - PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend(PyObject *func, PyObject *obj, PyObject *args, PyObject *kwargs); diff --git a/Include/funcobject.h b/Include/funcobject.h index 5aff632..6b89c86 100644 --- a/Include/funcobject.h +++ b/Include/funcobject.h @@ -64,12 +64,6 @@ PyAPI_FUNC(PyObject *) _PyFunction_FastCallDict( PyObject **args, Py_ssize_t nargs, PyObject *kwargs); - -PyAPI_FUNC(PyObject *) _PyFunction_FastCallKeywords( - PyObject *func, - PyObject **stack, - Py_ssize_t nargs, - Py_ssize_t nkwargs); #endif /* Macros for direct access to these values. Type checks are *not* diff --git a/Objects/abstract.c b/Objects/abstract.c index 9e5405d..cf69b96 100644 --- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -2343,51 +2343,6 @@ _PyStack_AsDict(PyObject **stack, Py_ssize_t nkwargs, PyObject *func) return kwdict; } -PyObject * -_PyObject_FastCallKeywords(PyObject *func, PyObject **stack, Py_ssize_t nargs, - Py_ssize_t nkwargs) -{ - PyObject *args, *kwdict, *result; - - /* _PyObject_FastCallKeywords() must not be called with an exception set, - because it may clear it (directly or indirectly) and so the - caller loses its exception */ - assert(!PyErr_Occurred()); - - assert(func != NULL); - assert(nargs >= 0); - assert(nkwargs >= 0); - assert((nargs == 0 && nkwargs == 0) || stack != NULL); - - if (PyFunction_Check(func)) { - /* Fast-path: avoid temporary tuple or dict */ - return _PyFunction_FastCallKeywords(func, stack, nargs, nkwargs); - } - - if (PyCFunction_Check(func) && nkwargs == 0) { - return _PyCFunction_FastCallDict(func, stack, nargs, NULL); - } - - /* Slow-path: build temporary tuple and/or dict */ - args = _PyStack_AsTuple(stack, nargs); - - if (nkwargs > 0) { - kwdict = _PyStack_AsDict(stack + nargs, nkwargs, func); - if (kwdict == NULL) { - Py_DECREF(args); - return NULL; - } - } - else { - kwdict = NULL; - } - - result = PyObject_Call(func, args, kwdict); - Py_DECREF(args); - Py_XDECREF(kwdict); - return result; -} - /* Positional arguments are obj followed args. */ PyObject * _PyObject_Call_Prepend(PyObject *func, diff --git a/Python/ceval.c b/Python/ceval.c index 266b987..00d52b4 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -113,6 +113,7 @@ static PyObject * call_function(PyObject ***, int, uint64*, uint64*); #else static PyObject * call_function(PyObject ***, int); #endif +static PyObject * fast_function(PyObject *, PyObject **, Py_ssize_t, Py_ssize_t); static PyObject * do_call(PyObject *, PyObject ***, Py_ssize_t, Py_ssize_t); static PyObject * ext_do_call(PyObject *, PyObject ***, int, Py_ssize_t, Py_ssize_t); static PyObject * update_keyword_args(PyObject *, Py_ssize_t, PyObject ***, @@ -4766,7 +4767,7 @@ call_function(PyObject ***pp_stack, int oparg } READ_TIMESTAMP(*pintr0); if (PyFunction_Check(func)) { - x = _PyFunction_FastCallKeywords(func, (*pp_stack) - n, nargs, nkwargs); + x = fast_function(func, (*pp_stack) - n, nargs, nkwargs); } else { x = do_call(func, pp_stack, nargs, nkwargs); @@ -4779,7 +4780,7 @@ call_function(PyObject ***pp_stack, int oparg /* Clear the stack of the function object. Also removes the arguments in case they weren't consumed already - (_PyFunction_FastCallKeywords() and err_args() leave them on the stack). + (fast_function() and err_args() leave them on the stack). */ while ((*pp_stack) > pfunc) { w = EXT_POP(*pp_stack); @@ -4791,7 +4792,7 @@ call_function(PyObject ***pp_stack, int oparg return x; } -/* The _PyFunction_FastCallKeywords() function optimize calls for which no argument +/* The fast_function() function optimize calls for which no argument tuple is necessary; the objects are passed directly from the stack. For the simplest case -- a function that takes only positional arguments and is called with only positional arguments -- it @@ -4839,9 +4840,8 @@ _PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t nargs, /* Similar to _PyFunction_FastCall() but keywords are passed a (key, value) pairs in stack */ -PyObject * -_PyFunction_FastCallKeywords(PyObject *func, PyObject **stack, - Py_ssize_t nargs, Py_ssize_t nkwargs) +static PyObject * +fast_function(PyObject *func, PyObject **stack, Py_ssize_t nargs, Py_ssize_t nkwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); -- cgit v0.12