gh-91049: Introduce set vectorcall field API for PyFunctionObject

Doc/c-api/function.rst

@@ -83,6 +83,11 @@ There are a few functions specific to Python functions.
  Raises :exc:`SystemError` and returns ``-1`` on failure.
 
 
+.. c:function:: void PyFunction_SetVectorcall(PyFunctionObject *func, vectorcallfunc vectorcall)
+
+ Set the vectorcall field of a given function object *func*
+
+
 .. c:function:: PyObject* PyFunction_GetClosure(PyObject *op)
 
  Return the closure associated with the function object *op*. This can be ``NULL``

Doc/whatsnew/3.12.rst

@@ -236,6 +236,10 @@ New Features
  an additional metaclass argument.
  (Contributed by Wenzel Jakob in :gh:`93012`.)
 
+* Add new function :c:func:`PyFunction_SetVectorcall` to the C API
+ which sets the vectorcall field of a given PyFunctionObject
+ (Contributed by Andrew Frost in :gh:`92257`.)
+
 Porting to Python 3.12
 ----------------------
 

Include/cpython/funcobject.h

@@ -69,6 +69,7 @@ PyAPI_FUNC(PyObject *) PyFunction_GetGlobals(PyObject *);
 PyAPI_FUNC(PyObject *) PyFunction_GetModule(PyObject *);
 PyAPI_FUNC(PyObject *) PyFunction_GetDefaults(PyObject *);
 PyAPI_FUNC(int) PyFunction_SetDefaults(PyObject *, PyObject *);
+PyAPI_FUNC(void) PyFunction_SetVectorcall(PyFunctionObject *, vectorcallfunc);
 PyAPI_FUNC(PyObject *) PyFunction_GetKwDefaults(PyObject *);
 PyAPI_FUNC(int) PyFunction_SetKwDefaults(PyObject *, PyObject *);
 PyAPI_FUNC(PyObject *) PyFunction_GetClosure(PyObject *);

Lib/test/test_call.py

@@ -665,6 +665,15 @@ def __call__(self, *args):
  self.assertEqual(expected, meth(*args1, **kwargs))
  self.assertEqual(expected, wrapped(*args, **kwargs))
 
+ def test_setvectorcall(self):
+ from _testcapi import function_setvectorcall
+ def f(num): return num + 1
+ num = 10
+ self.assertEqual(11, f(num))
+ function_setvectorcall(f)
+ # make sure specializer is triggered by running > 50 times
+ for _ in range(51):
+ self.assertIsNone(f(num))
 
 class A:
  def method_two_args(self, x, y):

Misc/NEWS.d/next/C API/2022-05-03-19-35-37.gh-issue-92193.61VoFL.rst

@@ -0,0 +1,6 @@
+CPython extensions providing optimized execution of Python bytecode (like Cinder JIT and Pyjion)
+can benefit from being able to modify the vectorcall field on instances of PyFunctionObject to allow calling the optimized path (e.g. JIT-compiled) directly.
+
+This PR introduces an API call where vectorcall field can be modified like so:
+
+`void PyFunction_SetVectorcall(PyFunctionObject *func, vectorcallfunc vectorcall);`

Modules/_testcapimodule.c

@@ -5356,6 +5356,23 @@ test_pyobject_vectorcall(PyObject *self, PyObject *args)
 }
 
 
+static PyObject *
+override_vectorcall(
+ PyObject *callable, PyObject *const *args, size_t nargsf, PyObject *kwnames) {
+ Py_RETURN_NONE;
+}
+
+static PyObject *
+function_setvectorcall(PyObject *self, PyObject *func)
+{
+ if (!PyFunction_Check(func)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ PyFunction_SetVectorcall((PyFunctionObject *)func, (vectorcallfunc)override_vectorcall);
+ Py_RETURN_NONE;
+}
+
 static PyObject *
 test_pyvectorcall_call(PyObject *self, PyObject *args)
 {
@@ -6340,6 +6357,7 @@ static PyMethodDef TestMethods[] = {
  {"pyobject_fastcall", test_pyobject_fastcall, METH_VARARGS},
  {"pyobject_fastcalldict", test_pyobject_fastcalldict, METH_VARARGS},
  {"pyobject_vectorcall", test_pyobject_vectorcall, METH_VARARGS},
+ {"function_setvectorcall", function_setvectorcall, METH_O},
  {"pyvectorcall_call", test_pyvectorcall_call, METH_VARARGS},
  {"stack_pointer", stack_pointer, METH_NOARGS},
 #ifdef W_STOPCODE

Objects/funcobject.c

@@ -134,6 +134,9 @@ uint32_t _PyFunction_GetVersionForCurrentState(PyFunctionObject *func)
  if (func->func_version != 0) {
  return func->func_version;
  }
+ if (func->vectorcall != _PyFunction_Vectorcall) {
+ return 0;
+ }
  if (next_func_version == 0) {
  return 0;
  }
@@ -209,6 +212,13 @@ PyFunction_SetDefaults(PyObject *op, PyObject *defaults)
  return 0;
 }
 
+void
+PyFunction_SetVectorcall(PyFunctionObject *func, vectorcallfunc vectorcall)
+{
+ func->func_version = 0;
+ func->vectorcall = vectorcall;
+}
+
 PyObject *
 PyFunction_GetKwDefaults(PyObject *op)
 {

Python/ceval.c

@@ -4686,7 +4686,9 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
  function = PEEK(total_args + 1);
  int positional_args = total_args - KWNAMES_LEN();
  // Check if the call can be inlined or not
- if (Py_TYPE(function) == &PyFunction_Type && tstate->interp->eval_frame == NULL) {
+ if (Py_TYPE(function) == &PyFunction_Type &&
+ tstate->interp->eval_frame == NULL &&
+ ((PyFunctionObject *)function)->vectorcall == _PyFunction_Vectorcall) {
  int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(function))->co_flags;
  PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : PyFunction_GET_GLOBALS(function);
  STACK_SHRINK(total_args);