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