Debian Codegraph @

Modules/clinic/_opcode.c.h

raw
1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
6 # include "pycore_gc.h" // PyGC_Head
7 # include "pycore_runtime.h" // _Py_ID()
8 #endif
9 #include "pycore_modsupport.h" // _PyArg_UnpackKeywords()
10
11 PyDoc_STRVAR(_opcode_stack_effect__doc__,
12 "stack_effect($module, opcode, oparg=None, /, *, jump=None)\n"
13 "--\n"
14 "\n"
15 "Compute the stack effect of the opcode.");
16
17 #define _OPCODE_STACK_EFFECT_METHODDEF \
18 {"stack_effect", _PyCFunction_CAST(_opcode_stack_effect), METH_FASTCALL|METH_KEYWORDS, _opcode_stack_effect__doc__},
19
20 static int
21 _opcode_stack_effect_impl(PyObject *module, int opcode, PyObject *oparg,
22 PyObject *jump);
23
24 static PyObject *
25 _opcode_stack_effect(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
26 {
27 PyObject *return_value = NULL;
28 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
29
30 #define NUM_KEYWORDS 1
31 static struct {
32 PyGC_Head _this_is_not_used;
33 PyObject_VAR_HEAD
34 Py_hash_t ob_hash;
35 PyObject *ob_item[NUM_KEYWORDS];
36 } _kwtuple = {
37 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
38 .ob_hash = -1,
39 .ob_item = { &_Py_ID(jump), },
40 };
41 #undef NUM_KEYWORDS
42 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
43
44 #else // !Py_BUILD_CORE
45 # define KWTUPLE NULL
46 #endif // !Py_BUILD_CORE
47
48 static const char * const _keywords[] = {"", "", "jump", NULL};
49 static _PyArg_Parser _parser = {
50 .keywords = _keywords,
51 .fname = "stack_effect",
52 .kwtuple = KWTUPLE,
53 };
54 #undef KWTUPLE
55 PyObject *argsbuf[3];
56 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
57 int opcode;
58 PyObject *oparg = Py_None;
59 PyObject *jump = Py_None;
60 int _return_value;
61
62 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
63 /*minpos*/ 1, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
64 if (!args) {
65 goto exit;
66 }
67 opcode = PyLong_AsInt(args[0]);
68 if (opcode == -1 && PyErr_Occurred()) {
69 goto exit;
70 }
71 if (nargs < 2) {
72 goto skip_optional_posonly;
73 }
74 noptargs--;
75 oparg = args[1];
76 skip_optional_posonly:
77 if (!noptargs) {
78 goto skip_optional_kwonly;
79 }
80 jump = args[2];
81 skip_optional_kwonly:
82 _return_value = _opcode_stack_effect_impl(module, opcode, oparg, jump);
83 if ((_return_value == -1) && PyErr_Occurred()) {
84 goto exit;
85 }
86 return_value = PyLong_FromLong((long)_return_value);
87
88 exit:
89 return return_value;
90 }
91
92 PyDoc_STRVAR(_opcode_is_valid__doc__,
93 "is_valid($module, /, opcode)\n"
94 "--\n"
95 "\n"
96 "Return True if opcode is valid, False otherwise.");
97
98 #define _OPCODE_IS_VALID_METHODDEF \
99 {"is_valid", _PyCFunction_CAST(_opcode_is_valid), METH_FASTCALL|METH_KEYWORDS, _opcode_is_valid__doc__},
100
101 static int
102 _opcode_is_valid_impl(PyObject *module, int opcode);
103
104 static PyObject *
105 _opcode_is_valid(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
106 {
107 PyObject *return_value = NULL;
108 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
109
110 #define NUM_KEYWORDS 1
111 static struct {
112 PyGC_Head _this_is_not_used;
113 PyObject_VAR_HEAD
114 Py_hash_t ob_hash;
115 PyObject *ob_item[NUM_KEYWORDS];
116 } _kwtuple = {
117 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
118 .ob_hash = -1,
119 .ob_item = { &_Py_ID(opcode), },
120 };
121 #undef NUM_KEYWORDS
122 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
123
124 #else // !Py_BUILD_CORE
125 # define KWTUPLE NULL
126 #endif // !Py_BUILD_CORE
127
128 static const char * const _keywords[] = {"opcode", NULL};
129 static _PyArg_Parser _parser = {
130 .keywords = _keywords,
131 .fname = "is_valid",
132 .kwtuple = KWTUPLE,
133 };
134 #undef KWTUPLE
135 PyObject *argsbuf[1];
136 int opcode;
137 int _return_value;
138
139 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
140 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
141 if (!args) {
142 goto exit;
143 }
144 opcode = PyLong_AsInt(args[0]);
145 if (opcode == -1 && PyErr_Occurred()) {
146 goto exit;
147 }
148 _return_value = _opcode_is_valid_impl(module, opcode);
149 if ((_return_value == -1) && PyErr_Occurred()) {
150 goto exit;
151 }
152 return_value = PyBool_FromLong((long)_return_value);
153
154 exit:
155 return return_value;
156 }
157
158 PyDoc_STRVAR(_opcode_has_arg__doc__,
159 "has_arg($module, /, opcode)\n"
160 "--\n"
161 "\n"
162 "Return True if the opcode uses its oparg, False otherwise.");
163
164 #define _OPCODE_HAS_ARG_METHODDEF \
165 {"has_arg", _PyCFunction_CAST(_opcode_has_arg), METH_FASTCALL|METH_KEYWORDS, _opcode_has_arg__doc__},
166
167 static int
168 _opcode_has_arg_impl(PyObject *module, int opcode);
169
170 static PyObject *
171 _opcode_has_arg(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
172 {
173 PyObject *return_value = NULL;
174 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
175
176 #define NUM_KEYWORDS 1
177 static struct {
178 PyGC_Head _this_is_not_used;
179 PyObject_VAR_HEAD
180 Py_hash_t ob_hash;
181 PyObject *ob_item[NUM_KEYWORDS];
182 } _kwtuple = {
183 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
184 .ob_hash = -1,
185 .ob_item = { &_Py_ID(opcode), },
186 };
187 #undef NUM_KEYWORDS
188 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
189
190 #else // !Py_BUILD_CORE
191 # define KWTUPLE NULL
192 #endif // !Py_BUILD_CORE
193
194 static const char * const _keywords[] = {"opcode", NULL};
195 static _PyArg_Parser _parser = {
196 .keywords = _keywords,
197 .fname = "has_arg",
198 .kwtuple = KWTUPLE,
199 };
200 #undef KWTUPLE
201 PyObject *argsbuf[1];
202 int opcode;
203 int _return_value;
204
205 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
206 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
207 if (!args) {
208 goto exit;
209 }
210 opcode = PyLong_AsInt(args[0]);
211 if (opcode == -1 && PyErr_Occurred()) {
212 goto exit;
213 }
214 _return_value = _opcode_has_arg_impl(module, opcode);
215 if ((_return_value == -1) && PyErr_Occurred()) {
216 goto exit;
217 }
218 return_value = PyBool_FromLong((long)_return_value);
219
220 exit:
221 return return_value;
222 }
223
224 PyDoc_STRVAR(_opcode_has_const__doc__,
225 "has_const($module, /, opcode)\n"
226 "--\n"
227 "\n"
228 "Return True if the opcode accesses a constant, False otherwise.");
229
230 #define _OPCODE_HAS_CONST_METHODDEF \
231 {"has_const", _PyCFunction_CAST(_opcode_has_const), METH_FASTCALL|METH_KEYWORDS, _opcode_has_const__doc__},
232
233 static int
234 _opcode_has_const_impl(PyObject *module, int opcode);
235
236 static PyObject *
237 _opcode_has_const(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
238 {
239 PyObject *return_value = NULL;
240 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
241
242 #define NUM_KEYWORDS 1
243 static struct {
244 PyGC_Head _this_is_not_used;
245 PyObject_VAR_HEAD
246 Py_hash_t ob_hash;
247 PyObject *ob_item[NUM_KEYWORDS];
248 } _kwtuple = {
249 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
250 .ob_hash = -1,
251 .ob_item = { &_Py_ID(opcode), },
252 };
253 #undef NUM_KEYWORDS
254 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
255
256 #else // !Py_BUILD_CORE
257 # define KWTUPLE NULL
258 #endif // !Py_BUILD_CORE
259
260 static const char * const _keywords[] = {"opcode", NULL};
261 static _PyArg_Parser _parser = {
262 .keywords = _keywords,
263 .fname = "has_const",
264 .kwtuple = KWTUPLE,
265 };
266 #undef KWTUPLE
267 PyObject *argsbuf[1];
268 int opcode;
269 int _return_value;
270
271 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
272 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
273 if (!args) {
274 goto exit;
275 }
276 opcode = PyLong_AsInt(args[0]);
277 if (opcode == -1 && PyErr_Occurred()) {
278 goto exit;
279 }
280 _return_value = _opcode_has_const_impl(module, opcode);
281 if ((_return_value == -1) && PyErr_Occurred()) {
282 goto exit;
283 }
284 return_value = PyBool_FromLong((long)_return_value);
285
286 exit:
287 return return_value;
288 }
289
290 PyDoc_STRVAR(_opcode_has_name__doc__,
291 "has_name($module, /, opcode)\n"
292 "--\n"
293 "\n"
294 "Return True if the opcode accesses an attribute by name, False otherwise.");
295
296 #define _OPCODE_HAS_NAME_METHODDEF \
297 {"has_name", _PyCFunction_CAST(_opcode_has_name), METH_FASTCALL|METH_KEYWORDS, _opcode_has_name__doc__},
298
299 static int
300 _opcode_has_name_impl(PyObject *module, int opcode);
301
302 static PyObject *
303 _opcode_has_name(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
304 {
305 PyObject *return_value = NULL;
306 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
307
308 #define NUM_KEYWORDS 1
309 static struct {
310 PyGC_Head _this_is_not_used;
311 PyObject_VAR_HEAD
312 Py_hash_t ob_hash;
313 PyObject *ob_item[NUM_KEYWORDS];
314 } _kwtuple = {
315 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
316 .ob_hash = -1,
317 .ob_item = { &_Py_ID(opcode), },
318 };
319 #undef NUM_KEYWORDS
320 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
321
322 #else // !Py_BUILD_CORE
323 # define KWTUPLE NULL
324 #endif // !Py_BUILD_CORE
325
326 static const char * const _keywords[] = {"opcode", NULL};
327 static _PyArg_Parser _parser = {
328 .keywords = _keywords,
329 .fname = "has_name",
330 .kwtuple = KWTUPLE,
331 };
332 #undef KWTUPLE
333 PyObject *argsbuf[1];
334 int opcode;
335 int _return_value;
336
337 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
338 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
339 if (!args) {
340 goto exit;
341 }
342 opcode = PyLong_AsInt(args[0]);
343 if (opcode == -1 && PyErr_Occurred()) {
344 goto exit;
345 }
346 _return_value = _opcode_has_name_impl(module, opcode);
347 if ((_return_value == -1) && PyErr_Occurred()) {
348 goto exit;
349 }
350 return_value = PyBool_FromLong((long)_return_value);
351
352 exit:
353 return return_value;
354 }
355
356 PyDoc_STRVAR(_opcode_has_jump__doc__,
357 "has_jump($module, /, opcode)\n"
358 "--\n"
359 "\n"
360 "Return True if the opcode has a jump target, False otherwise.");
361
362 #define _OPCODE_HAS_JUMP_METHODDEF \
363 {"has_jump", _PyCFunction_CAST(_opcode_has_jump), METH_FASTCALL|METH_KEYWORDS, _opcode_has_jump__doc__},
364
365 static int
366 _opcode_has_jump_impl(PyObject *module, int opcode);
367
368 static PyObject *
369 _opcode_has_jump(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
370 {
371 PyObject *return_value = NULL;
372 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
373
374 #define NUM_KEYWORDS 1
375 static struct {
376 PyGC_Head _this_is_not_used;
377 PyObject_VAR_HEAD
378 Py_hash_t ob_hash;
379 PyObject *ob_item[NUM_KEYWORDS];
380 } _kwtuple = {
381 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
382 .ob_hash = -1,
383 .ob_item = { &_Py_ID(opcode), },
384 };
385 #undef NUM_KEYWORDS
386 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
387
388 #else // !Py_BUILD_CORE
389 # define KWTUPLE NULL
390 #endif // !Py_BUILD_CORE
391
392 static const char * const _keywords[] = {"opcode", NULL};
393 static _PyArg_Parser _parser = {
394 .keywords = _keywords,
395 .fname = "has_jump",
396 .kwtuple = KWTUPLE,
397 };
398 #undef KWTUPLE
399 PyObject *argsbuf[1];
400 int opcode;
401 int _return_value;
402
403 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
404 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
405 if (!args) {
406 goto exit;
407 }
408 opcode = PyLong_AsInt(args[0]);
409 if (opcode == -1 && PyErr_Occurred()) {
410 goto exit;
411 }
412 _return_value = _opcode_has_jump_impl(module, opcode);
413 if ((_return_value == -1) && PyErr_Occurred()) {
414 goto exit;
415 }
416 return_value = PyBool_FromLong((long)_return_value);
417
418 exit:
419 return return_value;
420 }
421
422 PyDoc_STRVAR(_opcode_has_free__doc__,
423 "has_free($module, /, opcode)\n"
424 "--\n"
425 "\n"
426 "Return True if the opcode accesses a free variable, False otherwise.\n"
427 "\n"
428 "Note that \'free\' in this context refers to names in the current scope\n"
429 "that are referenced by inner scopes or names in outer scopes that are\n"
430 "referenced from this scope. It does not include references to global\n"
431 "or builtin scopes.");
432
433 #define _OPCODE_HAS_FREE_METHODDEF \
434 {"has_free", _PyCFunction_CAST(_opcode_has_free), METH_FASTCALL|METH_KEYWORDS, _opcode_has_free__doc__},
435
436 static int
437 _opcode_has_free_impl(PyObject *module, int opcode);
438
439 static PyObject *
440 _opcode_has_free(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
441 {
442 PyObject *return_value = NULL;
443 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
444
445 #define NUM_KEYWORDS 1
446 static struct {
447 PyGC_Head _this_is_not_used;
448 PyObject_VAR_HEAD
449 Py_hash_t ob_hash;
450 PyObject *ob_item[NUM_KEYWORDS];
451 } _kwtuple = {
452 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
453 .ob_hash = -1,
454 .ob_item = { &_Py_ID(opcode), },
455 };
456 #undef NUM_KEYWORDS
457 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
458
459 #else // !Py_BUILD_CORE
460 # define KWTUPLE NULL
461 #endif // !Py_BUILD_CORE
462
463 static const char * const _keywords[] = {"opcode", NULL};
464 static _PyArg_Parser _parser = {
465 .keywords = _keywords,
466 .fname = "has_free",
467 .kwtuple = KWTUPLE,
468 };
469 #undef KWTUPLE
470 PyObject *argsbuf[1];
471 int opcode;
472 int _return_value;
473
474 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
475 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
476 if (!args) {
477 goto exit;
478 }
479 opcode = PyLong_AsInt(args[0]);
480 if (opcode == -1 && PyErr_Occurred()) {
481 goto exit;
482 }
483 _return_value = _opcode_has_free_impl(module, opcode);
484 if ((_return_value == -1) && PyErr_Occurred()) {
485 goto exit;
486 }
487 return_value = PyBool_FromLong((long)_return_value);
488
489 exit:
490 return return_value;
491 }
492
493 PyDoc_STRVAR(_opcode_has_local__doc__,
494 "has_local($module, /, opcode)\n"
495 "--\n"
496 "\n"
497 "Return True if the opcode accesses a local variable, False otherwise.");
498
499 #define _OPCODE_HAS_LOCAL_METHODDEF \
500 {"has_local", _PyCFunction_CAST(_opcode_has_local), METH_FASTCALL|METH_KEYWORDS, _opcode_has_local__doc__},
501
502 static int
503 _opcode_has_local_impl(PyObject *module, int opcode);
504
505 static PyObject *
506 _opcode_has_local(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
507 {
508 PyObject *return_value = NULL;
509 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
510
511 #define NUM_KEYWORDS 1
512 static struct {
513 PyGC_Head _this_is_not_used;
514 PyObject_VAR_HEAD
515 Py_hash_t ob_hash;
516 PyObject *ob_item[NUM_KEYWORDS];
517 } _kwtuple = {
518 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
519 .ob_hash = -1,
520 .ob_item = { &_Py_ID(opcode), },
521 };
522 #undef NUM_KEYWORDS
523 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
524
525 #else // !Py_BUILD_CORE
526 # define KWTUPLE NULL
527 #endif // !Py_BUILD_CORE
528
529 static const char * const _keywords[] = {"opcode", NULL};
530 static _PyArg_Parser _parser = {
531 .keywords = _keywords,
532 .fname = "has_local",
533 .kwtuple = KWTUPLE,
534 };
535 #undef KWTUPLE
536 PyObject *argsbuf[1];
537 int opcode;
538 int _return_value;
539
540 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
541 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
542 if (!args) {
543 goto exit;
544 }
545 opcode = PyLong_AsInt(args[0]);
546 if (opcode == -1 && PyErr_Occurred()) {
547 goto exit;
548 }
549 _return_value = _opcode_has_local_impl(module, opcode);
550 if ((_return_value == -1) && PyErr_Occurred()) {
551 goto exit;
552 }
553 return_value = PyBool_FromLong((long)_return_value);
554
555 exit:
556 return return_value;
557 }
558
559 PyDoc_STRVAR(_opcode_has_exc__doc__,
560 "has_exc($module, /, opcode)\n"
561 "--\n"
562 "\n"
563 "Return True if the opcode sets an exception handler, False otherwise.");
564
565 #define _OPCODE_HAS_EXC_METHODDEF \
566 {"has_exc", _PyCFunction_CAST(_opcode_has_exc), METH_FASTCALL|METH_KEYWORDS, _opcode_has_exc__doc__},
567
568 static int
569 _opcode_has_exc_impl(PyObject *module, int opcode);
570
571 static PyObject *
572 _opcode_has_exc(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
573 {
574 PyObject *return_value = NULL;
575 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
576
577 #define NUM_KEYWORDS 1
578 static struct {
579 PyGC_Head _this_is_not_used;
580 PyObject_VAR_HEAD
581 Py_hash_t ob_hash;
582 PyObject *ob_item[NUM_KEYWORDS];
583 } _kwtuple = {
584 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
585 .ob_hash = -1,
586 .ob_item = { &_Py_ID(opcode), },
587 };
588 #undef NUM_KEYWORDS
589 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
590
591 #else // !Py_BUILD_CORE
592 # define KWTUPLE NULL
593 #endif // !Py_BUILD_CORE
594
595 static const char * const _keywords[] = {"opcode", NULL};
596 static _PyArg_Parser _parser = {
597 .keywords = _keywords,
598 .fname = "has_exc",
599 .kwtuple = KWTUPLE,
600 };
601 #undef KWTUPLE
602 PyObject *argsbuf[1];
603 int opcode;
604 int _return_value;
605
606 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
607 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
608 if (!args) {
609 goto exit;
610 }
611 opcode = PyLong_AsInt(args[0]);
612 if (opcode == -1 && PyErr_Occurred()) {
613 goto exit;
614 }
615 _return_value = _opcode_has_exc_impl(module, opcode);
616 if ((_return_value == -1) && PyErr_Occurred()) {
617 goto exit;
618 }
619 return_value = PyBool_FromLong((long)_return_value);
620
621 exit:
622 return return_value;
623 }
624
625 PyDoc_STRVAR(_opcode_get_specialization_stats__doc__,
626 "get_specialization_stats($module, /)\n"
627 "--\n"
628 "\n"
629 "Return the specialization stats");
630
631 #define _OPCODE_GET_SPECIALIZATION_STATS_METHODDEF \
632 {"get_specialization_stats", (PyCFunction)_opcode_get_specialization_stats, METH_NOARGS, _opcode_get_specialization_stats__doc__},
633
634 static PyObject *
635 _opcode_get_specialization_stats_impl(PyObject *module);
636
637 static PyObject *
638 _opcode_get_specialization_stats(PyObject *module, PyObject *Py_UNUSED(ignored))
639 {
640 return _opcode_get_specialization_stats_impl(module);
641 }
642
643 PyDoc_STRVAR(_opcode_get_nb_ops__doc__,
644 "get_nb_ops($module, /)\n"
645 "--\n"
646 "\n"
647 "Return array of symbols of binary ops.\n"
648 "\n"
649 "Indexed by the BINARY_OP oparg value.");
650
651 #define _OPCODE_GET_NB_OPS_METHODDEF \
652 {"get_nb_ops", (PyCFunction)_opcode_get_nb_ops, METH_NOARGS, _opcode_get_nb_ops__doc__},
653
654 static PyObject *
655 _opcode_get_nb_ops_impl(PyObject *module);
656
657 static PyObject *
658 _opcode_get_nb_ops(PyObject *module, PyObject *Py_UNUSED(ignored))
659 {
660 return _opcode_get_nb_ops_impl(module);
661 }
662
663 PyDoc_STRVAR(_opcode_get_intrinsic1_descs__doc__,
664 "get_intrinsic1_descs($module, /)\n"
665 "--\n"
666 "\n"
667 "Return a list of names of the unary intrinsics.");
668
669 #define _OPCODE_GET_INTRINSIC1_DESCS_METHODDEF \
670 {"get_intrinsic1_descs", (PyCFunction)_opcode_get_intrinsic1_descs, METH_NOARGS, _opcode_get_intrinsic1_descs__doc__},
671
672 static PyObject *
673 _opcode_get_intrinsic1_descs_impl(PyObject *module);
674
675 static PyObject *
676 _opcode_get_intrinsic1_descs(PyObject *module, PyObject *Py_UNUSED(ignored))
677 {
678 return _opcode_get_intrinsic1_descs_impl(module);
679 }
680
681 PyDoc_STRVAR(_opcode_get_intrinsic2_descs__doc__,
682 "get_intrinsic2_descs($module, /)\n"
683 "--\n"
684 "\n"
685 "Return a list of names of the binary intrinsics.");
686
687 #define _OPCODE_GET_INTRINSIC2_DESCS_METHODDEF \
688 {"get_intrinsic2_descs", (PyCFunction)_opcode_get_intrinsic2_descs, METH_NOARGS, _opcode_get_intrinsic2_descs__doc__},
689
690 static PyObject *
691 _opcode_get_intrinsic2_descs_impl(PyObject *module);
692
693 static PyObject *
694 _opcode_get_intrinsic2_descs(PyObject *module, PyObject *Py_UNUSED(ignored))
695 {
696 return _opcode_get_intrinsic2_descs_impl(module);
697 }
698
699 PyDoc_STRVAR(_opcode_get_special_method_names__doc__,
700 "get_special_method_names($module, /)\n"
701 "--\n"
702 "\n"
703 "Return a list of special method names.");
704
705 #define _OPCODE_GET_SPECIAL_METHOD_NAMES_METHODDEF \
706 {"get_special_method_names", (PyCFunction)_opcode_get_special_method_names, METH_NOARGS, _opcode_get_special_method_names__doc__},
707
708 static PyObject *
709 _opcode_get_special_method_names_impl(PyObject *module);
710
711 static PyObject *
712 _opcode_get_special_method_names(PyObject *module, PyObject *Py_UNUSED(ignored))
713 {
714 return _opcode_get_special_method_names_impl(module);
715 }
716
717 PyDoc_STRVAR(_opcode_get_executor__doc__,
718 "get_executor($module, /, code, offset)\n"
719 "--\n"
720 "\n"
721 "Return the executor object at offset in code if exists, None otherwise.");
722
723 #define _OPCODE_GET_EXECUTOR_METHODDEF \
724 {"get_executor", _PyCFunction_CAST(_opcode_get_executor), METH_FASTCALL|METH_KEYWORDS, _opcode_get_executor__doc__},
725
726 static PyObject *
727 _opcode_get_executor_impl(PyObject *module, PyObject *code, int offset);
728
729 static PyObject *
730 _opcode_get_executor(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
731 {
732 PyObject *return_value = NULL;
733 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
734
735 #define NUM_KEYWORDS 2
736 static struct {
737 PyGC_Head _this_is_not_used;
738 PyObject_VAR_HEAD
739 Py_hash_t ob_hash;
740 PyObject *ob_item[NUM_KEYWORDS];
741 } _kwtuple = {
742 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
743 .ob_hash = -1,
744 .ob_item = { &_Py_ID(code), &_Py_ID(offset), },
745 };
746 #undef NUM_KEYWORDS
747 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
748
749 #else // !Py_BUILD_CORE
750 # define KWTUPLE NULL
751 #endif // !Py_BUILD_CORE
752
753 static const char * const _keywords[] = {"code", "offset", NULL};
754 static _PyArg_Parser _parser = {
755 .keywords = _keywords,
756 .fname = "get_executor",
757 .kwtuple = KWTUPLE,
758 };
759 #undef KWTUPLE
760 PyObject *argsbuf[2];
761 PyObject *code;
762 int offset;
763
764 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
765 /*minpos*/ 2, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
766 if (!args) {
767 goto exit;
768 }
769 code = args[0];
770 offset = PyLong_AsInt(args[1]);
771 if (offset == -1 && PyErr_Occurred()) {
772 goto exit;
773 }
774 return_value = _opcode_get_executor_impl(module, code, offset);
775
776 exit:
777 return return_value;
778 }
779 /*[clinic end generated code: output=a11f02989c3175d7 input=a9049054013a1b77]*/