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