1
2/* Method object implementation */
3
4#include "Python.h"
5#include "pycore_ceval.h" // _Py_EnterRecursiveCall()
6#include "pycore_object.h"
7#include "pycore_pyerrors.h"
8#include "pycore_pystate.h" // _PyThreadState_GET()
9#include "structmember.h" // PyMemberDef
10
11/* undefine macro trampoline to PyCFunction_NewEx */
12#undef PyCFunction_New
13/* undefine macro trampoline to PyCMethod_New */
14#undef PyCFunction_NewEx
15
16/* Forward declarations */
17static PyObject * cfunction_vectorcall_FASTCALL(
18 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
19static PyObject * cfunction_vectorcall_FASTCALL_KEYWORDS(
20 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
21static PyObject * cfunction_vectorcall_FASTCALL_KEYWORDS_METHOD(
22 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
23static PyObject * cfunction_vectorcall_NOARGS(
24 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
25static PyObject * cfunction_vectorcall_O(
26 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames);
27static PyObject * cfunction_call(
28 PyObject *func, PyObject *args, PyObject *kwargs);
29
30
31PyObject *
32PyCFunction_New(PyMethodDef *ml, PyObject *self)
33{
34 return PyCFunction_NewEx(ml, self, NULL);
35}
36
37PyObject *
38PyCFunction_NewEx(PyMethodDef *ml, PyObject *self, PyObject *module)
39{
40 return PyCMethod_New(ml, self, module, NULL);
41}
42
43PyObject *
44PyCMethod_New(PyMethodDef *ml, PyObject *self, PyObject *module, PyTypeObject *cls)
45{
46 /* Figure out correct vectorcall function to use */
47 vectorcallfunc vectorcall;
48 switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS |
49 METH_O | METH_KEYWORDS | METH_METHOD))
50 {
51 case METH_VARARGS:
52 case METH_VARARGS | METH_KEYWORDS:
53 /* For METH_VARARGS functions, it's more efficient to use tp_call
54 * instead of vectorcall. */
55 vectorcall = NULL;
56 break;
57 case METH_FASTCALL:
58 vectorcall = cfunction_vectorcall_FASTCALL;
59 break;
60 case METH_FASTCALL | METH_KEYWORDS:
61 vectorcall = cfunction_vectorcall_FASTCALL_KEYWORDS;
62 break;
63 case METH_NOARGS:
64 vectorcall = cfunction_vectorcall_NOARGS;
65 break;
66 case METH_O:
67 vectorcall = cfunction_vectorcall_O;
68 break;
69 case METH_METHOD | METH_FASTCALL | METH_KEYWORDS:
70 vectorcall = cfunction_vectorcall_FASTCALL_KEYWORDS_METHOD;
71 break;
72 default:
73 PyErr_Format(PyExc_SystemError,
74 "%s() method: bad call flags", ml->ml_name);
75 return NULL;
76 }
77
78 PyCFunctionObject *op = NULL;
79
80 if (ml->ml_flags & METH_METHOD) {
81 if (!cls) {
82 PyErr_SetString(PyExc_SystemError,
83 "attempting to create PyCMethod with a METH_METHOD "
84 "flag but no class");
85 return NULL;
86 }
87 PyCMethodObject *om = PyObject_GC_New(PyCMethodObject, &PyCMethod_Type);
88 if (om == NULL) {
89 return NULL;
90 }
91 Py_INCREF(cls);
92 om->mm_class = cls;
93 op = (PyCFunctionObject *)om;
94 } else {
95 if (cls) {
96 PyErr_SetString(PyExc_SystemError,
97 "attempting to create PyCFunction with class "
98 "but no METH_METHOD flag");
99 return NULL;
100 }
101 op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
102 if (op == NULL) {
103 return NULL;
104 }
105 }
106
107 op->m_weakreflist = NULL;
108 op->m_ml = ml;
109 Py_XINCREF(self);
110 op->m_self = self;
111 Py_XINCREF(module);
112 op->m_module = module;
113 op->vectorcall = vectorcall;
114 _PyObject_GC_TRACK(op);
115 return (PyObject *)op;
116}
117
118PyCFunction
119PyCFunction_GetFunction(PyObject *op)
120{
121 if (!PyCFunction_Check(op)) {
122 PyErr_BadInternalCall();
123 return NULL;
124 }
125 return PyCFunction_GET_FUNCTION(op);
126}
127
128PyObject *
129PyCFunction_GetSelf(PyObject *op)
130{
131 if (!PyCFunction_Check(op)) {
132 PyErr_BadInternalCall();
133 return NULL;
134 }
135 return PyCFunction_GET_SELF(op);
136}
137
138int
139PyCFunction_GetFlags(PyObject *op)
140{
141 if (!PyCFunction_Check(op)) {
142 PyErr_BadInternalCall();
143 return -1;
144 }
145 return PyCFunction_GET_FLAGS(op);
146}
147
148PyTypeObject *
149PyCMethod_GetClass(PyObject *op)
150{
151 if (!PyCFunction_Check(op)) {
152 PyErr_BadInternalCall();
153 return NULL;
154 }
155 return PyCFunction_GET_CLASS(op);
156}
157
158/* Methods (the standard built-in methods, that is) */
159
160static void
161meth_dealloc(PyCFunctionObject *m)
162{
163 // The Py_TRASHCAN mechanism requires that we be able to
164 // call PyObject_GC_UnTrack twice on an object.
165 PyObject_GC_UnTrack(m);
166 Py_TRASHCAN_BEGIN(m, meth_dealloc);
167 if (m->m_weakreflist != NULL) {
168 PyObject_ClearWeakRefs((PyObject*) m);
169 }
170 // Dereference class before m_self: PyCFunction_GET_CLASS accesses
171 // PyMethodDef m_ml, which could be kept alive by m_self
172 Py_XDECREF(PyCFunction_GET_CLASS(m));
173 Py_XDECREF(m->m_self);
174 Py_XDECREF(m->m_module);
175 PyObject_GC_Del(m);
176 Py_TRASHCAN_END;
177}
178
179static PyObject *
180meth_reduce(PyCFunctionObject *m, PyObject *Py_UNUSED(ignored))
181{
182 _Py_IDENTIFIER(getattr);
183
184 if (m->m_self == NULL || PyModule_Check(m->m_self))
185 return PyUnicode_FromString(m->m_ml->ml_name);
186
187 return Py_BuildValue("N(Os)", _PyEval_GetBuiltinId(&PyId_getattr),
188 m->m_self, m->m_ml->ml_name);
189}
190
191static PyMethodDef meth_methods[] = {
192 {"__reduce__", (PyCFunction)meth_reduce, METH_NOARGS, NULL},
193 {NULL, NULL}
194};
195
196static PyObject *
197meth_get__text_signature__(PyCFunctionObject *m, void *closure)
198{
199 return _PyType_GetTextSignatureFromInternalDoc(m->m_ml->ml_name, m->m_ml->ml_doc);
200}
201
202static PyObject *
203meth_get__doc__(PyCFunctionObject *m, void *closure)
204{
205 return _PyType_GetDocFromInternalDoc(m->m_ml->ml_name, m->m_ml->ml_doc);
206}
207
208static PyObject *
209meth_get__name__(PyCFunctionObject *m, void *closure)
210{
211 return PyUnicode_FromString(m->m_ml->ml_name);
212}
213
214static PyObject *
215meth_get__qualname__(PyCFunctionObject *m, void *closure)
216{
217 /* If __self__ is a module or NULL, return m.__name__
218 (e.g. len.__qualname__ == 'len')
219
220 If __self__ is a type, return m.__self__.__qualname__ + '.' + m.__name__
221 (e.g. dict.fromkeys.__qualname__ == 'dict.fromkeys')
222
223 Otherwise return type(m.__self__).__qualname__ + '.' + m.__name__
224 (e.g. [].append.__qualname__ == 'list.append') */
225 PyObject *type, *type_qualname, *res;
226 _Py_IDENTIFIER(__qualname__);
227
228 if (m->m_self == NULL || PyModule_Check(m->m_self))
229 return PyUnicode_FromString(m->m_ml->ml_name);
230
231 type = PyType_Check(m->m_self) ? m->m_self : (PyObject*)Py_TYPE(m->m_self);
232
233 type_qualname = _PyObject_GetAttrId(type, &PyId___qualname__);
234 if (type_qualname == NULL)
235 return NULL;
236
237 if (!PyUnicode_Check(type_qualname)) {
238 PyErr_SetString(PyExc_TypeError, "<method>.__class__."
239 "__qualname__ is not a unicode object");
240 Py_XDECREF(type_qualname);
241 return NULL;
242 }
243
244 res = PyUnicode_FromFormat("%S.%s", type_qualname, m->m_ml->ml_name);
245 Py_DECREF(type_qualname);
246 return res;
247}
248
249static int
250meth_traverse(PyCFunctionObject *m, visitproc visit, void *arg)
251{
252 Py_VISIT(PyCFunction_GET_CLASS(m));
253 Py_VISIT(m->m_self);
254 Py_VISIT(m->m_module);
255 return 0;
256}
257
258static PyObject *
259meth_get__self__(PyCFunctionObject *m, void *closure)
260{
261 PyObject *self;
262
263 self = PyCFunction_GET_SELF(m);
264 if (self == NULL)
265 self = Py_None;
266 Py_INCREF(self);
267 return self;
268}
269
270static PyGetSetDef meth_getsets [] = {
271 {"__doc__", (getter)meth_get__doc__, NULL, NULL},
272 {"__name__", (getter)meth_get__name__, NULL, NULL},
273 {"__qualname__", (getter)meth_get__qualname__, NULL, NULL},
274 {"__self__", (getter)meth_get__self__, NULL, NULL},
275 {"__text_signature__", (getter)meth_get__text_signature__, NULL, NULL},
276 {0}
277};
278
279#define OFF(x) offsetof(PyCFunctionObject, x)
280
281static PyMemberDef meth_members[] = {
282 {"__module__", T_OBJECT, OFF(m_module), 0},
283 {NULL}
284};
285
286static PyObject *
287meth_repr(PyCFunctionObject *m)
288{
289 if (m->m_self == NULL || PyModule_Check(m->m_self))
290 return PyUnicode_FromFormat("<built-in function %s>",
291 m->m_ml->ml_name);
292 return PyUnicode_FromFormat("<built-in method %s of %s object at %p>",
293 m->m_ml->ml_name,
294 Py_TYPE(m->m_self)->tp_name,
295 m->m_self);
296}
297
298static PyObject *
299meth_richcompare(PyObject *self, PyObject *other, int op)
300{
301 PyCFunctionObject *a, *b;
302 PyObject *res;
303 int eq;
304
305 if ((op != Py_EQ && op != Py_NE) ||
306 !PyCFunction_Check(self) ||
307 !PyCFunction_Check(other))
308 {
309 Py_RETURN_NOTIMPLEMENTED;
310 }
311 a = (PyCFunctionObject *)self;
312 b = (PyCFunctionObject *)other;
313 eq = a->m_self == b->m_self;
314 if (eq)
315 eq = a->m_ml->ml_meth == b->m_ml->ml_meth;
316 if (op == Py_EQ)
317 res = eq ? Py_True : Py_False;
318 else
319 res = eq ? Py_False : Py_True;
320 Py_INCREF(res);
321 return res;
322}
323
324static Py_hash_t
325meth_hash(PyCFunctionObject *a)
326{
327 Py_hash_t x, y;
328 x = _Py_HashPointer(a->m_self);
329 y = _Py_HashPointer((void*)(a->m_ml->ml_meth));
330 x ^= y;
331 if (x == -1)
332 x = -2;
333 return x;
334}
335
336
337PyTypeObject PyCFunction_Type = {
338 PyVarObject_HEAD_INIT(&PyType_Type, 0)
339 "builtin_function_or_method",
340 sizeof(PyCFunctionObject),
341 0,
342 (destructor)meth_dealloc, /* tp_dealloc */
343 offsetof(PyCFunctionObject, vectorcall), /* tp_vectorcall_offset */
344 0, /* tp_getattr */
345 0, /* tp_setattr */
346 0, /* tp_as_async */
347 (reprfunc)meth_repr, /* tp_repr */
348 0, /* tp_as_number */
349 0, /* tp_as_sequence */
350 0, /* tp_as_mapping */
351 (hashfunc)meth_hash, /* tp_hash */
352 cfunction_call, /* tp_call */
353 0, /* tp_str */
354 PyObject_GenericGetAttr, /* tp_getattro */
355 0, /* tp_setattro */
356 0, /* tp_as_buffer */
357 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
358 Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
359 0, /* tp_doc */
360 (traverseproc)meth_traverse, /* tp_traverse */
361 0, /* tp_clear */
362 meth_richcompare, /* tp_richcompare */
363 offsetof(PyCFunctionObject, m_weakreflist), /* tp_weaklistoffset */
364 0, /* tp_iter */
365 0, /* tp_iternext */
366 meth_methods, /* tp_methods */
367 meth_members, /* tp_members */
368 meth_getsets, /* tp_getset */
369 0, /* tp_base */
370 0, /* tp_dict */
371};
372
373PyTypeObject PyCMethod_Type = {
374 PyVarObject_HEAD_INIT(&PyType_Type, 0)
375 .tp_name = "builtin_method",
376 .tp_basicsize = sizeof(PyCMethodObject),
377 .tp_base = &PyCFunction_Type,
378};
379
380/* Vectorcall functions for each of the PyCFunction calling conventions,
381 * except for METH_VARARGS (possibly combined with METH_KEYWORDS) which
382 * doesn't use vectorcall.
383 *
384 * First, common helpers
385 */
386
387static inline int
388cfunction_check_kwargs(PyThreadState *tstate, PyObject *func, PyObject *kwnames)
389{
390 assert(!_PyErr_Occurred(tstate));
391 assert(PyCFunction_Check(func));
392 if (kwnames && PyTuple_GET_SIZE(kwnames)) {
393 PyObject *funcstr = _PyObject_FunctionStr(func);
394 if (funcstr != NULL) {
395 _PyErr_Format(tstate, PyExc_TypeError,
396 "%U takes no keyword arguments", funcstr);
397 Py_DECREF(funcstr);
398 }
399 return -1;
400 }
401 return 0;
402}
403
404typedef void (*funcptr)(void);
405
406static inline funcptr
407cfunction_enter_call(PyThreadState *tstate, PyObject *func)
408{
409 if (_Py_EnterRecursiveCall(tstate, " while calling a Python object")) {
410 return NULL;
411 }
412 return (funcptr)PyCFunction_GET_FUNCTION(func);
413}
414
415/* Now the actual vectorcall functions */
416static PyObject *
417cfunction_vectorcall_FASTCALL(
418 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
419{
420 PyThreadState *tstate = _PyThreadState_GET();
421 if (cfunction_check_kwargs(tstate, func, kwnames)) {
422 return NULL;
423 }
424 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
425 _PyCFunctionFast meth = (_PyCFunctionFast)
426 cfunction_enter_call(tstate, func);
427 if (meth == NULL) {
428 return NULL;
429 }
430 PyObject *result = meth(PyCFunction_GET_SELF(func), args, nargs);
431 _Py_LeaveRecursiveCall(tstate);
432 return result;
433}
434
435static PyObject *
436cfunction_vectorcall_FASTCALL_KEYWORDS(
437 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
438{
439 PyThreadState *tstate = _PyThreadState_GET();
440 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
441 _PyCFunctionFastWithKeywords meth = (_PyCFunctionFastWithKeywords)
442 cfunction_enter_call(tstate, func);
443 if (meth == NULL) {
444 return NULL;
445 }
446 PyObject *result = meth(PyCFunction_GET_SELF(func), args, nargs, kwnames);
447 _Py_LeaveRecursiveCall(tstate);
448 return result;
449}
450
451static PyObject *
452cfunction_vectorcall_FASTCALL_KEYWORDS_METHOD(
453 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
454{
455 PyThreadState *tstate = _PyThreadState_GET();
456 PyTypeObject *cls = PyCFunction_GET_CLASS(func);
457 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
458 PyCMethod meth = (PyCMethod)cfunction_enter_call(tstate, func);
459 if (meth == NULL) {
460 return NULL;
461 }
462 PyObject *result = meth(PyCFunction_GET_SELF(func), cls, args, nargs, kwnames);
463 _Py_LeaveRecursiveCall(tstate);
464 return result;
465}
466
467static PyObject *
468cfunction_vectorcall_NOARGS(
469 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
470{
471 PyThreadState *tstate = _PyThreadState_GET();
472 if (cfunction_check_kwargs(tstate, func, kwnames)) {
473 return NULL;
474 }
475 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
476 if (nargs != 0) {
477 PyObject *funcstr = _PyObject_FunctionStr(func);
478 if (funcstr != NULL) {
479 _PyErr_Format(tstate, PyExc_TypeError,
480 "%U takes no arguments (%zd given)", funcstr, nargs);
481 Py_DECREF(funcstr);
482 }
483 return NULL;
484 }
485 PyCFunction meth = (PyCFunction)cfunction_enter_call(tstate, func);
486 if (meth == NULL) {
487 return NULL;
488 }
489 PyObject *result = meth(PyCFunction_GET_SELF(func), NULL);
490 _Py_LeaveRecursiveCall(tstate);
491 return result;
492}
493
494static PyObject *
495cfunction_vectorcall_O(
496 PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames)
497{
498 PyThreadState *tstate = _PyThreadState_GET();
499 if (cfunction_check_kwargs(tstate, func, kwnames)) {
500 return NULL;
501 }
502 Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
503 if (nargs != 1) {
504 PyObject *funcstr = _PyObject_FunctionStr(func);
505 if (funcstr != NULL) {
506 _PyErr_Format(tstate, PyExc_TypeError,
507 "%U takes exactly one argument (%zd given)", funcstr, nargs);
508 Py_DECREF(funcstr);
509 }
510 return NULL;
511 }
512 PyCFunction meth = (PyCFunction)cfunction_enter_call(tstate, func);
513 if (meth == NULL) {
514 return NULL;
515 }
516 PyObject *result = meth(PyCFunction_GET_SELF(func), args[0]);
517 _Py_LeaveRecursiveCall(tstate);
518 return result;
519}
520
521
522static PyObject *
523cfunction_call(PyObject *func, PyObject *args, PyObject *kwargs)
524{
525 assert(kwargs == NULL || PyDict_Check(kwargs));
526
527 PyThreadState *tstate = _PyThreadState_GET();
528 assert(!_PyErr_Occurred(tstate));
529
530 int flags = PyCFunction_GET_FLAGS(func);
531 if (!(flags & METH_VARARGS)) {
532 /* If this is not a METH_VARARGS function, delegate to vectorcall */
533 return PyVectorcall_Call(func, args, kwargs);
534 }
535
536 /* For METH_VARARGS, we cannot use vectorcall as the vectorcall pointer
537 * is NULL. This is intentional, since vectorcall would be slower. */
538 PyCFunction meth = PyCFunction_GET_FUNCTION(func);
539 PyObject *self = PyCFunction_GET_SELF(func);
540
541 PyObject *result;
542 if (flags & METH_KEYWORDS) {
543 result = (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, args, kwargs);
544 }
545 else {
546 if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {
547 _PyErr_Format(tstate, PyExc_TypeError,
548 "%.200s() takes no keyword arguments",
549 ((PyCFunctionObject*)func)->m_ml->ml_name);
550 return NULL;
551 }
552 result = meth(self, args);
553 }
554 return _Py_CheckFunctionResult(tstate, func, result, NULL);
555}
556