Branch data Line data Source code
1 : : /* Execute compiled code */
2 : :
3 : : /* XXX TO DO:
4 : : XXX speed up searching for keywords by using a dictionary
5 : : XXX document it!
6 : : */
7 : :
8 : : #define _PY_INTERPRETER
9 : :
10 : : #include "Python.h"
11 : : #include "pycore_abstract.h" // _PyIndex_Check()
12 : : #include "pycore_call.h" // _PyObject_FastCallDictTstate()
13 : : #include "pycore_ceval.h" // _PyEval_SignalAsyncExc()
14 : : #include "pycore_code.h"
15 : : #include "pycore_function.h"
16 : : #include "pycore_initconfig.h" // _PyStatus_OK()
17 : : #include "pycore_long.h" // _PyLong_GetZero()
18 : : #include "pycore_object.h" // _PyObject_GC_TRACK()
19 : : #include "pycore_moduleobject.h" // PyModuleObject
20 : : #include "pycore_opcode.h" // EXTRA_CASES
21 : : #include "pycore_pyerrors.h" // _PyErr_Fetch()
22 : : #include "pycore_pylifecycle.h" // _PyErr_Print()
23 : : #include "pycore_pymem.h" // _PyMem_IsPtrFreed()
24 : : #include "pycore_pystate.h" // _PyInterpreterState_GET()
25 : : #include "pycore_range.h" // _PyRangeIterObject
26 : : #include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs
27 : : #include "pycore_sysmodule.h" // _PySys_Audit()
28 : : #include "pycore_tuple.h" // _PyTuple_ITEMS()
29 : : #include "pycore_emscripten_signal.h" // _Py_CHECK_EMSCRIPTEN_SIGNALS
30 : :
31 : : #include "pycore_dict.h"
32 : : #include "dictobject.h"
33 : : #include "pycore_frame.h"
34 : : #include "opcode.h"
35 : : #include "pydtrace.h"
36 : : #include "setobject.h"
37 : : #include "structmember.h" // struct PyMemberDef, T_OFFSET_EX
38 : :
39 : : #include <ctype.h>
40 : : #include <stdbool.h>
41 : :
42 : : #ifdef Py_DEBUG
43 : : /* For debugging the interpreter: */
44 : : # define LLTRACE 1 /* Low-level trace feature */
45 : : #endif
46 : :
47 : : #if !defined(Py_BUILD_CORE)
48 : : # error "ceval.c must be build with Py_BUILD_CORE define for best performance"
49 : : #endif
50 : :
51 : : #ifndef Py_DEBUG
52 : : // GH-89279: The MSVC compiler does not inline these static inline functions
53 : : // in PGO build in _PyEval_EvalFrameDefault(), because this function is over
54 : : // the limit of PGO, and that limit cannot be configured.
55 : : // Define them as macros to make sure that they are always inlined by the
56 : : // preprocessor.
57 : :
58 : : #undef Py_DECREF
59 : : #define Py_DECREF(arg) \
60 : : do { \
61 : : _Py_DECREF_STAT_INC(); \
62 : : PyObject *op = _PyObject_CAST(arg); \
63 : : if (--op->ob_refcnt == 0) { \
64 : : destructor dealloc = Py_TYPE(op)->tp_dealloc; \
65 : : (*dealloc)(op); \
66 : : } \
67 : : } while (0)
68 : :
69 : : #undef Py_XDECREF
70 : : #define Py_XDECREF(arg) \
71 : : do { \
72 : : PyObject *xop = _PyObject_CAST(arg); \
73 : : if (xop != NULL) { \
74 : : Py_DECREF(xop); \
75 : : } \
76 : : } while (0)
77 : :
78 : : #undef Py_IS_TYPE
79 : : #define Py_IS_TYPE(ob, type) \
80 : : (_PyObject_CAST(ob)->ob_type == (type))
81 : :
82 : : #undef _Py_DECREF_SPECIALIZED
83 : : #define _Py_DECREF_SPECIALIZED(arg, dealloc) \
84 : : do { \
85 : : _Py_DECREF_STAT_INC(); \
86 : : PyObject *op = _PyObject_CAST(arg); \
87 : : if (--op->ob_refcnt == 0) { \
88 : : destructor d = (destructor)(dealloc); \
89 : : d(op); \
90 : : } \
91 : : } while (0)
92 : : #endif
93 : :
94 : : // GH-89279: Similar to above, force inlining by using a macro.
95 : : #if defined(_MSC_VER) && SIZEOF_INT == 4
96 : : #define _Py_atomic_load_relaxed_int32(ATOMIC_VAL) (assert(sizeof((ATOMIC_VAL)->_value) == 4), *((volatile int*)&((ATOMIC_VAL)->_value)))
97 : : #else
98 : : #define _Py_atomic_load_relaxed_int32(ATOMIC_VAL) _Py_atomic_load_relaxed(ATOMIC_VAL)
99 : : #endif
100 : :
101 : :
102 : : /* Forward declarations */
103 : : static PyObject *trace_call_function(
104 : : PyThreadState *tstate, PyObject *callable, PyObject **stack,
105 : : Py_ssize_t oparg, PyObject *kwnames);
106 : : static PyObject * do_call_core(
107 : : PyThreadState *tstate, PyObject *func,
108 : : PyObject *callargs, PyObject *kwdict, int use_tracing);
109 : :
110 : : #ifdef LLTRACE
111 : : static void
112 : : dump_stack(_PyInterpreterFrame *frame, PyObject **stack_pointer)
113 : : {
114 : : PyObject **stack_base = _PyFrame_Stackbase(frame);
115 : : PyObject *type, *value, *traceback;
116 : : PyErr_Fetch(&type, &value, &traceback);
117 : : printf(" stack=[");
118 : : for (PyObject **ptr = stack_base; ptr < stack_pointer; ptr++) {
119 : : if (ptr != stack_base) {
120 : : printf(", ");
121 : : }
122 : : if (PyObject_Print(*ptr, stdout, 0) != 0) {
123 : : PyErr_Clear();
124 : : printf("<%s object at %p>",
125 : : Py_TYPE(*ptr)->tp_name, (void *)(*ptr));
126 : : }
127 : : }
128 : : printf("]\n");
129 : : fflush(stdout);
130 : : PyErr_Restore(type, value, traceback);
131 : : }
132 : :
133 : : static void
134 : : lltrace_instruction(_PyInterpreterFrame *frame,
135 : : PyObject **stack_pointer,
136 : : _Py_CODEUNIT *next_instr)
137 : : {
138 : : dump_stack(frame, stack_pointer);
139 : : int oparg = _Py_OPARG(*next_instr);
140 : : int opcode = _Py_OPCODE(*next_instr);
141 : : const char *opname = _PyOpcode_OpName[opcode];
142 : : assert(opname != NULL);
143 : : int offset = (int)(next_instr - _PyCode_CODE(frame->f_code));
144 : : if (HAS_ARG(opcode)) {
145 : : printf("%d: %s %d\n", offset * 2, opname, oparg);
146 : : }
147 : : else {
148 : : printf("%d: %s\n", offset * 2, opname);
149 : : }
150 : : fflush(stdout);
151 : : }
152 : : static void
153 : : lltrace_resume_frame(_PyInterpreterFrame *frame)
154 : : {
155 : : PyFunctionObject *f = frame->f_func;
156 : : if (f == NULL) {
157 : : printf("\nResuming frame.");
158 : : return;
159 : : }
160 : : PyObject *type, *value, *traceback;
161 : : PyErr_Fetch(&type, &value, &traceback);
162 : : PyObject *name = f->func_qualname;
163 : : if (name == NULL) {
164 : : name = f->func_name;
165 : : }
166 : : printf("\nResuming frame");
167 : : if (name) {
168 : : printf(" for ");
169 : : if (PyObject_Print(name, stdout, 0) < 0) {
170 : : PyErr_Clear();
171 : : }
172 : : }
173 : : if (f->func_module) {
174 : : printf(" in module ");
175 : : if (PyObject_Print(f->func_module, stdout, 0) < 0) {
176 : : PyErr_Clear();
177 : : }
178 : : }
179 : : printf("\n");
180 : : fflush(stdout);
181 : : PyErr_Restore(type, value, traceback);
182 : : }
183 : : #endif
184 : : static int call_trace(Py_tracefunc, PyObject *,
185 : : PyThreadState *, _PyInterpreterFrame *,
186 : : int, PyObject *);
187 : : static int call_trace_protected(Py_tracefunc, PyObject *,
188 : : PyThreadState *, _PyInterpreterFrame *,
189 : : int, PyObject *);
190 : : static void call_exc_trace(Py_tracefunc, PyObject *,
191 : : PyThreadState *, _PyInterpreterFrame *);
192 : : static int maybe_call_line_trace(Py_tracefunc, PyObject *,
193 : : PyThreadState *, _PyInterpreterFrame *, int);
194 : : static void maybe_dtrace_line(_PyInterpreterFrame *, PyTraceInfo *, int);
195 : : static void dtrace_function_entry(_PyInterpreterFrame *);
196 : : static void dtrace_function_return(_PyInterpreterFrame *);
197 : :
198 : : static PyObject * import_name(PyThreadState *, _PyInterpreterFrame *,
199 : : PyObject *, PyObject *, PyObject *);
200 : : static PyObject * import_from(PyThreadState *, PyObject *, PyObject *);
201 : : static int import_all_from(PyThreadState *, PyObject *, PyObject *);
202 : : static void format_exc_check_arg(PyThreadState *, PyObject *, const char *, PyObject *);
203 : : static void format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg);
204 : : static int check_args_iterable(PyThreadState *, PyObject *func, PyObject *vararg);
205 : : static int check_except_type_valid(PyThreadState *tstate, PyObject* right);
206 : : static int check_except_star_type_valid(PyThreadState *tstate, PyObject* right);
207 : : static void format_kwargs_error(PyThreadState *, PyObject *func, PyObject *kwargs);
208 : : static void format_awaitable_error(PyThreadState *, PyTypeObject *, int);
209 : : static int get_exception_handler(PyCodeObject *, int, int*, int*, int*);
210 : : static _PyInterpreterFrame *
211 : : _PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,
212 : : PyObject *locals, PyObject* const* args,
213 : : size_t argcount, PyObject *kwnames);
214 : : static void
215 : : _PyEvalFrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame *frame);
216 : :
217 : : #define NAME_ERROR_MSG \
218 : : "name '%.200s' is not defined"
219 : : #define UNBOUNDLOCAL_ERROR_MSG \
220 : : "cannot access local variable '%s' where it is not associated with a value"
221 : : #define UNBOUNDFREE_ERROR_MSG \
222 : : "cannot access free variable '%s' where it is not associated with a" \
223 : : " value in enclosing scope"
224 : :
225 : : #ifndef NDEBUG
226 : : /* Ensure that tstate is valid: sanity check for PyEval_AcquireThread() and
227 : : PyEval_RestoreThread(). Detect if tstate memory was freed. It can happen
228 : : when a thread continues to run after Python finalization, especially
229 : : daemon threads. */
230 : : static int
231 : : is_tstate_valid(PyThreadState *tstate)
232 : : {
233 : : assert(!_PyMem_IsPtrFreed(tstate));
234 : : assert(!_PyMem_IsPtrFreed(tstate->interp));
235 : : return 1;
236 : : }
237 : : #endif
238 : :
239 : :
240 : : /* This can set eval_breaker to 0 even though gil_drop_request became
241 : : 1. We believe this is all right because the eval loop will release
242 : : the GIL eventually anyway. */
243 : : static inline void
244 : 9509067 : COMPUTE_EVAL_BREAKER(PyInterpreterState *interp,
245 : : struct _ceval_runtime_state *ceval,
246 : : struct _ceval_state *ceval2)
247 : : {
248 [ + + + + : 9509067 : _Py_atomic_store_relaxed(&ceval2->eval_breaker,
+ + + + ]
249 : : _Py_atomic_load_relaxed_int32(&ceval2->gil_drop_request)
250 : : | (_Py_atomic_load_relaxed_int32(&ceval->signals_pending)
251 : : && _Py_ThreadCanHandleSignals(interp))
252 : : | (_Py_atomic_load_relaxed_int32(&ceval2->pending.calls_to_do)
253 : : && _Py_ThreadCanHandlePendingCalls())
254 : : | ceval2->pending.async_exc);
255 : 9509067 : }
256 : :
257 : :
258 : : static inline void
259 : 90518 : SET_GIL_DROP_REQUEST(PyInterpreterState *interp)
260 : : {
261 : 90518 : struct _ceval_state *ceval2 = &interp->ceval;
262 : 90518 : _Py_atomic_store_relaxed(&ceval2->gil_drop_request, 1);
263 : 90518 : _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);
264 : 90518 : }
265 : :
266 : :
267 : : static inline void
268 : 35430 : RESET_GIL_DROP_REQUEST(PyInterpreterState *interp)
269 : : {
270 : 35430 : struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
271 : 35430 : struct _ceval_state *ceval2 = &interp->ceval;
272 : 35430 : _Py_atomic_store_relaxed(&ceval2->gil_drop_request, 0);
273 : 35430 : COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
274 : 35430 : }
275 : :
276 : :
277 : : static inline void
278 : 101 : SIGNAL_PENDING_CALLS(PyInterpreterState *interp)
279 : : {
280 : 101 : struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
281 : 101 : struct _ceval_state *ceval2 = &interp->ceval;
282 : 101 : _Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 1);
283 : 101 : COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
284 : 101 : }
285 : :
286 : :
287 : : static inline void
288 : 482 : UNSIGNAL_PENDING_CALLS(PyInterpreterState *interp)
289 : : {
290 : 482 : struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
291 : 482 : struct _ceval_state *ceval2 = &interp->ceval;
292 : 482 : _Py_atomic_store_relaxed(&ceval2->pending.calls_to_do, 0);
293 : 482 : COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
294 : 482 : }
295 : :
296 : :
297 : : static inline void
298 : 140674 : SIGNAL_PENDING_SIGNALS(PyInterpreterState *interp, int force)
299 : : {
300 : 140674 : struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
301 : 140674 : struct _ceval_state *ceval2 = &interp->ceval;
302 : 140674 : _Py_atomic_store_relaxed(&ceval->signals_pending, 1);
303 [ - + ]: 140674 : if (force) {
304 : 0 : _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);
305 : : }
306 : : else {
307 : : /* eval_breaker is not set to 1 if thread_can_handle_signals() is false */
308 : 140674 : COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
309 : : }
310 : 140674 : }
311 : :
312 : :
313 : : static inline void
314 : 31666 : UNSIGNAL_PENDING_SIGNALS(PyInterpreterState *interp)
315 : : {
316 : 31666 : struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
317 : 31666 : struct _ceval_state *ceval2 = &interp->ceval;
318 : 31666 : _Py_atomic_store_relaxed(&ceval->signals_pending, 0);
319 : 31666 : COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
320 : 31666 : }
321 : :
322 : :
323 : : static inline void
324 : 3 : SIGNAL_ASYNC_EXC(PyInterpreterState *interp)
325 : : {
326 : 3 : struct _ceval_state *ceval2 = &interp->ceval;
327 : 3 : ceval2->pending.async_exc = 1;
328 : 3 : _Py_atomic_store_relaxed(&ceval2->eval_breaker, 1);
329 : 3 : }
330 : :
331 : :
332 : : static inline void
333 : 2 : UNSIGNAL_ASYNC_EXC(PyInterpreterState *interp)
334 : : {
335 : 2 : struct _ceval_runtime_state *ceval = &interp->runtime->ceval;
336 : 2 : struct _ceval_state *ceval2 = &interp->ceval;
337 : 2 : ceval2->pending.async_exc = 0;
338 : 2 : COMPUTE_EVAL_BREAKER(interp, ceval, ceval2);
339 : 2 : }
340 : :
341 : :
342 : : #ifdef HAVE_ERRNO_H
343 : : #include <errno.h>
344 : : #endif
345 : : #include "ceval_gil.h"
346 : :
347 : : void _Py_NO_RETURN
348 : : _Py_FatalError_TstateNULL(const char *func)
349 : : {
350 : : _Py_FatalErrorFunc(func,
351 : : "the function must be called with the GIL held, "
352 : : "after Python initialization and before Python finalization, "
353 : : "but the GIL is released (the current Python thread state is NULL)");
354 : : }
355 : :
356 : : int
357 : 0 : _PyEval_ThreadsInitialized(_PyRuntimeState *runtime)
358 : : {
359 : 0 : return gil_created(&runtime->ceval.gil);
360 : : }
361 : :
362 : : int
363 : 0 : PyEval_ThreadsInitialized(void)
364 : : {
365 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
366 : 0 : return _PyEval_ThreadsInitialized(runtime);
367 : : }
368 : :
369 : : PyStatus
370 : 3138 : _PyEval_InitGIL(PyThreadState *tstate)
371 : : {
372 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(tstate->interp)) {
373 : : /* Currently, the GIL is shared by all interpreters,
374 : : and only the main interpreter is responsible to create
375 : : and destroy it. */
376 : 171 : return _PyStatus_OK();
377 : : }
378 : :
379 : 2967 : struct _gil_runtime_state *gil = &tstate->interp->runtime->ceval.gil;
380 : : assert(!gil_created(gil));
381 : :
382 : 2967 : PyThread_init_thread();
383 : 2967 : create_gil(gil);
384 : :
385 : 2967 : take_gil(tstate);
386 : :
387 : : assert(gil_created(gil));
388 : 2967 : return _PyStatus_OK();
389 : : }
390 : :
391 : : void
392 : 3138 : _PyEval_FiniGIL(PyInterpreterState *interp)
393 : : {
394 [ + + ]: 3138 : if (!_Py_IsMainInterpreter(interp)) {
395 : : /* Currently, the GIL is shared by all interpreters,
396 : : and only the main interpreter is responsible to create
397 : : and destroy it. */
398 : 171 : return;
399 : : }
400 : :
401 : 2967 : struct _gil_runtime_state *gil = &interp->runtime->ceval.gil;
402 [ + - ]: 2967 : if (!gil_created(gil)) {
403 : : /* First Py_InitializeFromConfig() call: the GIL doesn't exist
404 : : yet: do nothing. */
405 : 2967 : return;
406 : : }
407 : :
408 : 0 : destroy_gil(gil);
409 : : assert(!gil_created(gil));
410 : : }
411 : :
412 : : void
413 : 0 : PyEval_InitThreads(void)
414 : : {
415 : : /* Do nothing: kept for backward compatibility */
416 : 0 : }
417 : :
418 : : void
419 : 2957 : _PyEval_Fini(void)
420 : : {
421 : : #ifdef Py_STATS
422 : : _Py_PrintSpecializationStats(1);
423 : : #endif
424 : 2957 : }
425 : :
426 : : void
427 : 0 : PyEval_AcquireLock(void)
428 : : {
429 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
430 : 0 : PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
431 : 0 : _Py_EnsureTstateNotNULL(tstate);
432 : :
433 : 0 : take_gil(tstate);
434 : 0 : }
435 : :
436 : : void
437 : 0 : PyEval_ReleaseLock(void)
438 : : {
439 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
440 : 0 : PyThreadState *tstate = _PyRuntimeState_GetThreadState(runtime);
441 : : /* This function must succeed when the current thread state is NULL.
442 : : We therefore avoid PyThreadState_Get() which dumps a fatal error
443 : : in debug mode. */
444 : 0 : struct _ceval_runtime_state *ceval = &runtime->ceval;
445 : 0 : struct _ceval_state *ceval2 = &tstate->interp->ceval;
446 : 0 : drop_gil(ceval, ceval2, tstate);
447 : 0 : }
448 : :
449 : : void
450 : 8649 : _PyEval_ReleaseLock(PyThreadState *tstate)
451 : : {
452 : 8649 : struct _ceval_runtime_state *ceval = &tstate->interp->runtime->ceval;
453 : 8649 : struct _ceval_state *ceval2 = &tstate->interp->ceval;
454 : 8649 : drop_gil(ceval, ceval2, tstate);
455 : 8649 : }
456 : :
457 : : void
458 : 8773 : PyEval_AcquireThread(PyThreadState *tstate)
459 : : {
460 : 8773 : _Py_EnsureTstateNotNULL(tstate);
461 : :
462 : 8773 : take_gil(tstate);
463 : :
464 : 8773 : struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate;
465 [ - + ]: 8773 : if (_PyThreadState_Swap(gilstate, tstate) != NULL) {
466 : : Py_FatalError("non-NULL old thread state");
467 : : }
468 : 8773 : }
469 : :
470 : : void
471 : 12 : PyEval_ReleaseThread(PyThreadState *tstate)
472 : : {
473 : : assert(is_tstate_valid(tstate));
474 : :
475 : 12 : _PyRuntimeState *runtime = tstate->interp->runtime;
476 : 12 : PyThreadState *new_tstate = _PyThreadState_Swap(&runtime->gilstate, NULL);
477 [ - + ]: 12 : if (new_tstate != tstate) {
478 : : Py_FatalError("wrong thread state");
479 : : }
480 : 12 : struct _ceval_runtime_state *ceval = &runtime->ceval;
481 : 12 : struct _ceval_state *ceval2 = &tstate->interp->ceval;
482 : 12 : drop_gil(ceval, ceval2, tstate);
483 : 12 : }
484 : :
485 : : #ifdef HAVE_FORK
486 : : /* This function is called from PyOS_AfterFork_Child to destroy all threads
487 : : which are not running in the child process, and clear internal locks
488 : : which might be held by those threads. */
489 : : PyStatus
490 : 8 : _PyEval_ReInitThreads(PyThreadState *tstate)
491 : : {
492 : 8 : _PyRuntimeState *runtime = tstate->interp->runtime;
493 : :
494 : 8 : struct _gil_runtime_state *gil = &runtime->ceval.gil;
495 [ - + ]: 8 : if (!gil_created(gil)) {
496 : 0 : return _PyStatus_OK();
497 : : }
498 : 8 : recreate_gil(gil);
499 : :
500 : 8 : take_gil(tstate);
501 : :
502 : 8 : struct _pending_calls *pending = &tstate->interp->ceval.pending;
503 [ - + ]: 8 : if (_PyThread_at_fork_reinit(&pending->lock) < 0) {
504 : 0 : return _PyStatus_ERR("Can't reinitialize pending calls lock");
505 : : }
506 : :
507 : : /* Destroy all threads except the current one */
508 : 8 : _PyThreadState_DeleteExcept(runtime, tstate);
509 : 8 : return _PyStatus_OK();
510 : : }
511 : : #endif
512 : :
513 : : /* This function is used to signal that async exceptions are waiting to be
514 : : raised. */
515 : :
516 : : void
517 : 3 : _PyEval_SignalAsyncExc(PyInterpreterState *interp)
518 : : {
519 : 3 : SIGNAL_ASYNC_EXC(interp);
520 : 3 : }
521 : :
522 : : PyThreadState *
523 : 9261845 : PyEval_SaveThread(void)
524 : : {
525 : 9261845 : _PyRuntimeState *runtime = &_PyRuntime;
526 : 9261845 : PyThreadState *tstate = _PyThreadState_Swap(&runtime->gilstate, NULL);
527 : 9261845 : _Py_EnsureTstateNotNULL(tstate);
528 : :
529 : 9261845 : struct _ceval_runtime_state *ceval = &runtime->ceval;
530 : 9261845 : struct _ceval_state *ceval2 = &tstate->interp->ceval;
531 : : assert(gil_created(&ceval->gil));
532 : 9261845 : drop_gil(ceval, ceval2, tstate);
533 : 9261843 : return tstate;
534 : : }
535 : :
536 : : void
537 : 9261696 : PyEval_RestoreThread(PyThreadState *tstate)
538 : : {
539 : 9261696 : _Py_EnsureTstateNotNULL(tstate);
540 : :
541 : 9261790 : take_gil(tstate);
542 : :
543 : 9261733 : struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate;
544 : 9261733 : _PyThreadState_Swap(gilstate, tstate);
545 : 9261733 : }
546 : :
547 : :
548 : : /* Mechanism whereby asynchronously executing callbacks (e.g. UNIX
549 : : signal handlers or Mac I/O completion routines) can schedule calls
550 : : to a function to be called synchronously.
551 : : The synchronous function is called with one void* argument.
552 : : It should return 0 for success or -1 for failure -- failure should
553 : : be accompanied by an exception.
554 : :
555 : : If registry succeeds, the registry function returns 0; if it fails
556 : : (e.g. due to too many pending calls) it returns -1 (without setting
557 : : an exception condition).
558 : :
559 : : Note that because registry may occur from within signal handlers,
560 : : or other asynchronous events, calling malloc() is unsafe!
561 : :
562 : : Any thread can schedule pending calls, but only the main thread
563 : : will execute them.
564 : : There is no facility to schedule calls to a particular thread, but
565 : : that should be easy to change, should that ever be required. In
566 : : that case, the static variables here should go into the python
567 : : threadstate.
568 : : */
569 : :
570 : : void
571 : 140662 : _PyEval_SignalReceived(PyInterpreterState *interp)
572 : : {
573 : : #ifdef MS_WINDOWS
574 : : // bpo-42296: On Windows, _PyEval_SignalReceived() is called from a signal
575 : : // handler which can run in a thread different than the Python thread, in
576 : : // which case _Py_ThreadCanHandleSignals() is wrong. Ignore
577 : : // _Py_ThreadCanHandleSignals() and always set eval_breaker to 1.
578 : : //
579 : : // The next eval_frame_handle_pending() call will call
580 : : // _Py_ThreadCanHandleSignals() to recompute eval_breaker.
581 : : int force = 1;
582 : : #else
583 : 140662 : int force = 0;
584 : : #endif
585 : : /* bpo-30703: Function called when the C signal handler of Python gets a
586 : : signal. We cannot queue a callback using _PyEval_AddPendingCall() since
587 : : that function is not async-signal-safe. */
588 : 140662 : SIGNAL_PENDING_SIGNALS(interp, force);
589 : 140662 : }
590 : :
591 : : /* Push one item onto the queue while holding the lock. */
592 : : static int
593 : 101 : _push_pending_call(struct _pending_calls *pending,
594 : : int (*func)(void *), void *arg)
595 : : {
596 : 101 : int i = pending->last;
597 : 101 : int j = (i + 1) % NPENDINGCALLS;
598 [ - + ]: 101 : if (j == pending->first) {
599 : 0 : return -1; /* Queue full */
600 : : }
601 : 101 : pending->calls[i].func = func;
602 : 101 : pending->calls[i].arg = arg;
603 : 101 : pending->last = j;
604 : 101 : return 0;
605 : : }
606 : :
607 : : /* Pop one item off the queue while holding the lock. */
608 : : static void
609 : 583 : _pop_pending_call(struct _pending_calls *pending,
610 : : int (**func)(void *), void **arg)
611 : : {
612 : 583 : int i = pending->first;
613 [ + + ]: 583 : if (i == pending->last) {
614 : 482 : return; /* Queue empty */
615 : : }
616 : :
617 : 101 : *func = pending->calls[i].func;
618 : 101 : *arg = pending->calls[i].arg;
619 : 101 : pending->first = (i + 1) % NPENDINGCALLS;
620 : : }
621 : :
622 : : /* This implementation is thread-safe. It allows
623 : : scheduling to be made from any thread, and even from an executing
624 : : callback.
625 : : */
626 : :
627 : : int
628 : 101 : _PyEval_AddPendingCall(PyInterpreterState *interp,
629 : : int (*func)(void *), void *arg)
630 : : {
631 : 101 : struct _pending_calls *pending = &interp->ceval.pending;
632 : :
633 : : /* Ensure that _PyEval_InitPendingCalls() was called
634 : : and that _PyEval_FiniPendingCalls() is not called yet. */
635 : : assert(pending->lock != NULL);
636 : :
637 : 101 : PyThread_acquire_lock(pending->lock, WAIT_LOCK);
638 : 101 : int result = _push_pending_call(pending, func, arg);
639 : 101 : PyThread_release_lock(pending->lock);
640 : :
641 : : /* signal main loop */
642 : 101 : SIGNAL_PENDING_CALLS(interp);
643 : 101 : return result;
644 : : }
645 : :
646 : : int
647 : 96 : Py_AddPendingCall(int (*func)(void *), void *arg)
648 : : {
649 : : /* Best-effort to support subinterpreters and calls with the GIL released.
650 : :
651 : : First attempt _PyThreadState_GET() since it supports subinterpreters.
652 : :
653 : : If the GIL is released, _PyThreadState_GET() returns NULL . In this
654 : : case, use PyGILState_GetThisThreadState() which works even if the GIL
655 : : is released.
656 : :
657 : : Sadly, PyGILState_GetThisThreadState() doesn't support subinterpreters:
658 : : see bpo-10915 and bpo-15751.
659 : :
660 : : Py_AddPendingCall() doesn't require the caller to hold the GIL. */
661 : 96 : PyThreadState *tstate = _PyThreadState_GET();
662 [ + - ]: 96 : if (tstate == NULL) {
663 : 96 : tstate = PyGILState_GetThisThreadState();
664 : : }
665 : :
666 : : PyInterpreterState *interp;
667 [ + - ]: 96 : if (tstate != NULL) {
668 : 96 : interp = tstate->interp;
669 : : }
670 : : else {
671 : : /* Last resort: use the main interpreter */
672 : 0 : interp = _PyInterpreterState_Main();
673 : : }
674 : 96 : return _PyEval_AddPendingCall(interp, func, arg);
675 : : }
676 : :
677 : : static int
678 : 31679 : handle_signals(PyThreadState *tstate)
679 : : {
680 : : assert(is_tstate_valid(tstate));
681 [ + + ]: 31679 : if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
682 : 13 : return 0;
683 : : }
684 : :
685 : 31666 : UNSIGNAL_PENDING_SIGNALS(tstate->interp);
686 [ + + ]: 31666 : if (_PyErr_CheckSignalsTstate(tstate) < 0) {
687 : : /* On failure, re-schedule a call to handle_signals(). */
688 : 12 : SIGNAL_PENDING_SIGNALS(tstate->interp, 0);
689 : 12 : return -1;
690 : : }
691 : 31654 : return 0;
692 : : }
693 : :
694 : : static int
695 : 482 : make_pending_calls(PyInterpreterState *interp)
696 : : {
697 : : /* only execute pending calls on main thread */
698 [ - + ]: 482 : if (!_Py_ThreadCanHandlePendingCalls()) {
699 : 0 : return 0;
700 : : }
701 : :
702 : : /* don't perform recursive pending calls */
703 : : static int busy = 0;
704 [ - + ]: 482 : if (busy) {
705 : 0 : return 0;
706 : : }
707 : 482 : busy = 1;
708 : :
709 : : /* unsignal before starting to call callbacks, so that any callback
710 : : added in-between re-signals */
711 : 482 : UNSIGNAL_PENDING_CALLS(interp);
712 : 482 : int res = 0;
713 : :
714 : : /* perform a bounded number of calls, in case of recursion */
715 : 482 : struct _pending_calls *pending = &interp->ceval.pending;
716 [ + - ]: 583 : for (int i=0; i<NPENDINGCALLS; i++) {
717 : 583 : int (*func)(void *) = NULL;
718 : 583 : void *arg = NULL;
719 : :
720 : : /* pop one item off the queue while holding the lock */
721 : 583 : PyThread_acquire_lock(pending->lock, WAIT_LOCK);
722 : 583 : _pop_pending_call(pending, &func, &arg);
723 : 583 : PyThread_release_lock(pending->lock);
724 : :
725 : : /* having released the lock, perform the callback */
726 [ + + ]: 583 : if (func == NULL) {
727 : 482 : break;
728 : : }
729 : 101 : res = func(arg);
730 [ - + ]: 101 : if (res) {
731 : 0 : goto error;
732 : : }
733 : : }
734 : :
735 : 482 : busy = 0;
736 : 482 : return res;
737 : :
738 : 0 : error:
739 : 0 : busy = 0;
740 : 0 : SIGNAL_PENDING_CALLS(interp);
741 : 0 : return res;
742 : : }
743 : :
744 : : void
745 : 2957 : _Py_FinishPendingCalls(PyThreadState *tstate)
746 : : {
747 : : assert(PyGILState_Check());
748 : : assert(is_tstate_valid(tstate));
749 : :
750 : 2957 : struct _pending_calls *pending = &tstate->interp->ceval.pending;
751 : :
752 [ + - ]: 2957 : if (!_Py_atomic_load_relaxed_int32(&(pending->calls_to_do))) {
753 : 2957 : return;
754 : : }
755 : :
756 [ # # ]: 0 : if (make_pending_calls(tstate->interp) < 0) {
757 : : PyObject *exc, *val, *tb;
758 : 0 : _PyErr_Fetch(tstate, &exc, &val, &tb);
759 : 0 : PyErr_BadInternalCall();
760 : 0 : _PyErr_ChainExceptions(exc, val, tb);
761 : 0 : _PyErr_Print(tstate);
762 : : }
763 : : }
764 : :
765 : : /* Py_MakePendingCalls() is a simple wrapper for the sake
766 : : of backward-compatibility. */
767 : : int
768 : 405 : Py_MakePendingCalls(void)
769 : : {
770 : : assert(PyGILState_Check());
771 : :
772 : 405 : PyThreadState *tstate = _PyThreadState_GET();
773 : : assert(is_tstate_valid(tstate));
774 : :
775 : : /* Python signal handler doesn't really queue a callback: it only signals
776 : : that a signal was received, see _PyEval_SignalReceived(). */
777 : 405 : int res = handle_signals(tstate);
778 [ + + ]: 405 : if (res != 0) {
779 : 2 : return res;
780 : : }
781 : :
782 : 403 : res = make_pending_calls(tstate->interp);
783 [ - + ]: 403 : if (res != 0) {
784 : 0 : return res;
785 : : }
786 : :
787 : 403 : return 0;
788 : : }
789 : :
790 : : /* The interpreter's recursion limit */
791 : :
792 : : void
793 : 2988 : _PyEval_InitRuntimeState(struct _ceval_runtime_state *ceval)
794 : : {
795 : 2988 : _gil_initialize(&ceval->gil);
796 : 2988 : }
797 : :
798 : : void
799 : 3138 : _PyEval_InitState(struct _ceval_state *ceval, PyThread_type_lock pending_lock)
800 : : {
801 : 3138 : struct _pending_calls *pending = &ceval->pending;
802 : : assert(pending->lock == NULL);
803 : :
804 : 3138 : pending->lock = pending_lock;
805 : 3138 : }
806 : :
807 : : void
808 : 3125 : _PyEval_FiniState(struct _ceval_state *ceval)
809 : : {
810 : 3125 : struct _pending_calls *pending = &ceval->pending;
811 [ + - ]: 3125 : if (pending->lock != NULL) {
812 : 3125 : PyThread_free_lock(pending->lock);
813 : 3125 : pending->lock = NULL;
814 : : }
815 : 3125 : }
816 : :
817 : : int
818 : 238218 : Py_GetRecursionLimit(void)
819 : : {
820 : 238218 : PyInterpreterState *interp = _PyInterpreterState_GET();
821 : 238218 : return interp->ceval.recursion_limit;
822 : : }
823 : :
824 : : void
825 : 96 : Py_SetRecursionLimit(int new_limit)
826 : : {
827 : 96 : PyInterpreterState *interp = _PyInterpreterState_GET();
828 : 96 : interp->ceval.recursion_limit = new_limit;
829 [ + + ]: 192 : for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
830 : 96 : int depth = p->recursion_limit - p->recursion_remaining;
831 : 96 : p->recursion_limit = new_limit;
832 : 96 : p->recursion_remaining = new_limit - depth;
833 : : }
834 : 96 : }
835 : :
836 : : /* The function _Py_EnterRecursiveCallTstate() only calls _Py_CheckRecursiveCall()
837 : : if the recursion_depth reaches recursion_limit. */
838 : : int
839 : 16547 : _Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
840 : : {
841 : : /* Check against global limit first. */
842 : 16547 : int depth = tstate->recursion_limit - tstate->recursion_remaining;
843 [ - + ]: 16547 : if (depth < tstate->interp->ceval.recursion_limit) {
844 : 0 : tstate->recursion_limit = tstate->interp->ceval.recursion_limit;
845 : 0 : tstate->recursion_remaining = tstate->recursion_limit - depth;
846 : : assert(tstate->recursion_remaining > 0);
847 : 0 : return 0;
848 : : }
849 : : #ifdef USE_STACKCHECK
850 : : if (PyOS_CheckStack()) {
851 : : ++tstate->recursion_remaining;
852 : : _PyErr_SetString(tstate, PyExc_MemoryError, "Stack overflow");
853 : : return -1;
854 : : }
855 : : #endif
856 [ + + ]: 16547 : if (tstate->recursion_headroom) {
857 [ - + ]: 8205 : if (tstate->recursion_remaining < -50) {
858 : : /* Overflowing while handling an overflow. Give up. */
859 : : Py_FatalError("Cannot recover from stack overflow.");
860 : : }
861 : : }
862 : : else {
863 [ + - ]: 8342 : if (tstate->recursion_remaining <= 0) {
864 : 8342 : tstate->recursion_headroom++;
865 : 8342 : _PyErr_Format(tstate, PyExc_RecursionError,
866 : : "maximum recursion depth exceeded%s",
867 : : where);
868 : 8342 : tstate->recursion_headroom--;
869 : 8342 : ++tstate->recursion_remaining;
870 : 8342 : return -1;
871 : : }
872 : : }
873 : 8205 : return 0;
874 : : }
875 : :
876 : :
877 : : static const binaryfunc binary_ops[] = {
878 : : [NB_ADD] = PyNumber_Add,
879 : : [NB_AND] = PyNumber_And,
880 : : [NB_FLOOR_DIVIDE] = PyNumber_FloorDivide,
881 : : [NB_LSHIFT] = PyNumber_Lshift,
882 : : [NB_MATRIX_MULTIPLY] = PyNumber_MatrixMultiply,
883 : : [NB_MULTIPLY] = PyNumber_Multiply,
884 : : [NB_REMAINDER] = PyNumber_Remainder,
885 : : [NB_OR] = PyNumber_Or,
886 : : [NB_POWER] = _PyNumber_PowerNoMod,
887 : : [NB_RSHIFT] = PyNumber_Rshift,
888 : : [NB_SUBTRACT] = PyNumber_Subtract,
889 : : [NB_TRUE_DIVIDE] = PyNumber_TrueDivide,
890 : : [NB_XOR] = PyNumber_Xor,
891 : : [NB_INPLACE_ADD] = PyNumber_InPlaceAdd,
892 : : [NB_INPLACE_AND] = PyNumber_InPlaceAnd,
893 : : [NB_INPLACE_FLOOR_DIVIDE] = PyNumber_InPlaceFloorDivide,
894 : : [NB_INPLACE_LSHIFT] = PyNumber_InPlaceLshift,
895 : : [NB_INPLACE_MATRIX_MULTIPLY] = PyNumber_InPlaceMatrixMultiply,
896 : : [NB_INPLACE_MULTIPLY] = PyNumber_InPlaceMultiply,
897 : : [NB_INPLACE_REMAINDER] = PyNumber_InPlaceRemainder,
898 : : [NB_INPLACE_OR] = PyNumber_InPlaceOr,
899 : : [NB_INPLACE_POWER] = _PyNumber_InPlacePowerNoMod,
900 : : [NB_INPLACE_RSHIFT] = PyNumber_InPlaceRshift,
901 : : [NB_INPLACE_SUBTRACT] = PyNumber_InPlaceSubtract,
902 : : [NB_INPLACE_TRUE_DIVIDE] = PyNumber_InPlaceTrueDivide,
903 : : [NB_INPLACE_XOR] = PyNumber_InPlaceXor,
904 : : };
905 : :
906 : :
907 : : // PEP 634: Structural Pattern Matching
908 : :
909 : :
910 : : // Return a tuple of values corresponding to keys, with error checks for
911 : : // duplicate/missing keys.
912 : : static PyObject*
913 : 47 : match_keys(PyThreadState *tstate, PyObject *map, PyObject *keys)
914 : : {
915 : : assert(PyTuple_CheckExact(keys));
916 : 47 : Py_ssize_t nkeys = PyTuple_GET_SIZE(keys);
917 [ + + ]: 47 : if (!nkeys) {
918 : : // No keys means no items.
919 : 3 : return PyTuple_New(0);
920 : : }
921 : 44 : PyObject *seen = NULL;
922 : 44 : PyObject *dummy = NULL;
923 : 44 : PyObject *values = NULL;
924 : 44 : PyObject *get = NULL;
925 : : // We use the two argument form of map.get(key, default) for two reasons:
926 : : // - Atomically check for a key and get its value without error handling.
927 : : // - Don't cause key creation or resizing in dict subclasses like
928 : : // collections.defaultdict that define __missing__ (or similar).
929 : 44 : int meth_found = _PyObject_GetMethod(map, &_Py_ID(get), &get);
930 [ - + ]: 44 : if (get == NULL) {
931 : 0 : goto fail;
932 : : }
933 : 44 : seen = PySet_New(NULL);
934 [ - + ]: 44 : if (seen == NULL) {
935 : 0 : goto fail;
936 : : }
937 : : // dummy = object()
938 : 44 : dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);
939 [ - + ]: 44 : if (dummy == NULL) {
940 : 0 : goto fail;
941 : : }
942 : 44 : values = PyTuple_New(nkeys);
943 [ - + ]: 44 : if (values == NULL) {
944 : 0 : goto fail;
945 : : }
946 [ + + ]: 92 : for (Py_ssize_t i = 0; i < nkeys; i++) {
947 : 57 : PyObject *key = PyTuple_GET_ITEM(keys, i);
948 [ + + - + ]: 57 : if (PySet_Contains(seen, key) || PySet_Add(seen, key)) {
949 [ + - ]: 1 : if (!_PyErr_Occurred(tstate)) {
950 : : // Seen it before!
951 : 1 : _PyErr_Format(tstate, PyExc_ValueError,
952 : : "mapping pattern checks duplicate key (%R)", key);
953 : : }
954 : 1 : goto fail;
955 : : }
956 : 56 : PyObject *args[] = { map, key, dummy };
957 : 56 : PyObject *value = NULL;
958 [ + + ]: 56 : if (meth_found) {
959 : 55 : value = PyObject_Vectorcall(get, args, 3, NULL);
960 : : }
961 : : else {
962 : 1 : value = PyObject_Vectorcall(get, &args[1], 2, NULL);
963 : : }
964 [ - + ]: 56 : if (value == NULL) {
965 : 0 : goto fail;
966 : : }
967 [ + + ]: 56 : if (value == dummy) {
968 : : // key not in map!
969 [ - + ]: 8 : Py_DECREF(value);
970 [ + - ]: 8 : Py_DECREF(values);
971 : : // Return None:
972 : 8 : Py_INCREF(Py_None);
973 : 8 : values = Py_None;
974 : 8 : goto done;
975 : : }
976 : 48 : PyTuple_SET_ITEM(values, i, value);
977 : : }
978 : : // Success:
979 : 35 : done:
980 [ - + ]: 43 : Py_DECREF(get);
981 [ + - ]: 43 : Py_DECREF(seen);
982 [ + - ]: 43 : Py_DECREF(dummy);
983 : 43 : return values;
984 : 1 : fail:
985 [ + - - + ]: 1 : Py_XDECREF(get);
986 [ + - + - ]: 1 : Py_XDECREF(seen);
987 [ + - + - ]: 1 : Py_XDECREF(dummy);
988 [ + - + - ]: 1 : Py_XDECREF(values);
989 : 1 : return NULL;
990 : : }
991 : :
992 : : // Extract a named attribute from the subject, with additional bookkeeping to
993 : : // raise TypeErrors for repeated lookups. On failure, return NULL (with no
994 : : // error set). Use _PyErr_Occurred(tstate) to disambiguate.
995 : : static PyObject*
996 : 4542 : match_class_attr(PyThreadState *tstate, PyObject *subject, PyObject *type,
997 : : PyObject *name, PyObject *seen)
998 : : {
999 : : assert(PyUnicode_CheckExact(name));
1000 : : assert(PySet_CheckExact(seen));
1001 [ + + - + ]: 4542 : if (PySet_Contains(seen, name) || PySet_Add(seen, name)) {
1002 [ + - ]: 2 : if (!_PyErr_Occurred(tstate)) {
1003 : : // Seen it before!
1004 : 2 : _PyErr_Format(tstate, PyExc_TypeError,
1005 : : "%s() got multiple sub-patterns for attribute %R",
1006 : : ((PyTypeObject*)type)->tp_name, name);
1007 : : }
1008 : 2 : return NULL;
1009 : : }
1010 : 4540 : PyObject *attr = PyObject_GetAttr(subject, name);
1011 [ - + - - ]: 4540 : if (attr == NULL && _PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
1012 : 0 : _PyErr_Clear(tstate);
1013 : : }
1014 : 4540 : return attr;
1015 : : }
1016 : :
1017 : : // On success (match), return a tuple of extracted attributes. On failure (no
1018 : : // match), return NULL. Use _PyErr_Occurred(tstate) to disambiguate.
1019 : : static PyObject*
1020 : 12841 : match_class(PyThreadState *tstate, PyObject *subject, PyObject *type,
1021 : : Py_ssize_t nargs, PyObject *kwargs)
1022 : : {
1023 [ - + ]: 12841 : if (!PyType_Check(type)) {
1024 : 0 : const char *e = "called match pattern must be a type";
1025 : 0 : _PyErr_Format(tstate, PyExc_TypeError, e);
1026 : 0 : return NULL;
1027 : : }
1028 : : assert(PyTuple_CheckExact(kwargs));
1029 : : // First, an isinstance check:
1030 [ + + ]: 12841 : if (PyObject_IsInstance(subject, type) <= 0) {
1031 : 7283 : return NULL;
1032 : : }
1033 : : // So far so good:
1034 : 5558 : PyObject *seen = PySet_New(NULL);
1035 [ - + ]: 5558 : if (seen == NULL) {
1036 : 0 : return NULL;
1037 : : }
1038 : 5558 : PyObject *attrs = PyList_New(0);
1039 [ - + ]: 5558 : if (attrs == NULL) {
1040 [ # # ]: 0 : Py_DECREF(seen);
1041 : 0 : return NULL;
1042 : : }
1043 : : // NOTE: From this point on, goto fail on failure:
1044 : 5558 : PyObject *match_args = NULL;
1045 : : // First, the positional subpatterns:
1046 [ + + ]: 5558 : if (nargs) {
1047 : 4511 : int match_self = 0;
1048 : 4511 : match_args = PyObject_GetAttrString(type, "__match_args__");
1049 [ + + ]: 4511 : if (match_args) {
1050 [ + + ]: 4493 : if (!PyTuple_CheckExact(match_args)) {
1051 : 3 : const char *e = "%s.__match_args__ must be a tuple (got %s)";
1052 : 3 : _PyErr_Format(tstate, PyExc_TypeError, e,
1053 : : ((PyTypeObject *)type)->tp_name,
1054 : 3 : Py_TYPE(match_args)->tp_name);
1055 : 3 : goto fail;
1056 : : }
1057 : : }
1058 [ + - ]: 18 : else if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
1059 : 18 : _PyErr_Clear(tstate);
1060 : : // _Py_TPFLAGS_MATCH_SELF is only acknowledged if the type does not
1061 : : // define __match_args__. This is natural behavior for subclasses:
1062 : : // it's as if __match_args__ is some "magic" value that is lost as
1063 : : // soon as they redefine it.
1064 : 18 : match_args = PyTuple_New(0);
1065 : 18 : match_self = PyType_HasFeature((PyTypeObject*)type,
1066 : : _Py_TPFLAGS_MATCH_SELF);
1067 : : }
1068 : : else {
1069 : 0 : goto fail;
1070 : : }
1071 : : assert(PyTuple_CheckExact(match_args));
1072 [ + + ]: 4508 : Py_ssize_t allowed = match_self ? 1 : PyTuple_GET_SIZE(match_args);
1073 [ + + ]: 4508 : if (allowed < nargs) {
1074 [ - + ]: 2 : const char *plural = (allowed == 1) ? "" : "s";
1075 : 2 : _PyErr_Format(tstate, PyExc_TypeError,
1076 : : "%s() accepts %d positional sub-pattern%s (%d given)",
1077 : : ((PyTypeObject*)type)->tp_name,
1078 : : allowed, plural, nargs);
1079 : 2 : goto fail;
1080 : : }
1081 [ + + ]: 4506 : if (match_self) {
1082 : : // Easy. Copy the subject itself, and move on to kwargs.
1083 : 17 : PyList_Append(attrs, subject);
1084 : : }
1085 : : else {
1086 [ + + ]: 9012 : for (Py_ssize_t i = 0; i < nargs; i++) {
1087 : 4525 : PyObject *name = PyTuple_GET_ITEM(match_args, i);
1088 [ + + ]: 4525 : if (!PyUnicode_CheckExact(name)) {
1089 : 1 : _PyErr_Format(tstate, PyExc_TypeError,
1090 : : "__match_args__ elements must be strings "
1091 : 1 : "(got %s)", Py_TYPE(name)->tp_name);
1092 : 1 : goto fail;
1093 : : }
1094 : 4524 : PyObject *attr = match_class_attr(tstate, subject, type, name,
1095 : : seen);
1096 [ + + ]: 4524 : if (attr == NULL) {
1097 : 1 : goto fail;
1098 : : }
1099 : 4523 : PyList_Append(attrs, attr);
1100 [ - + ]: 4523 : Py_DECREF(attr);
1101 : : }
1102 : : }
1103 [ + - - + ]: 4504 : Py_CLEAR(match_args);
1104 : : }
1105 : : // Finally, the keyword subpatterns:
1106 [ + + ]: 5568 : for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(kwargs); i++) {
1107 : 18 : PyObject *name = PyTuple_GET_ITEM(kwargs, i);
1108 : 18 : PyObject *attr = match_class_attr(tstate, subject, type, name, seen);
1109 [ + + ]: 18 : if (attr == NULL) {
1110 : 1 : goto fail;
1111 : : }
1112 : 17 : PyList_Append(attrs, attr);
1113 [ - + ]: 17 : Py_DECREF(attr);
1114 : : }
1115 [ + - ]: 5550 : Py_SETREF(attrs, PyList_AsTuple(attrs));
1116 [ + - ]: 5550 : Py_DECREF(seen);
1117 : 5550 : return attrs;
1118 : 8 : fail:
1119 : : // We really don't care whether an error was raised or not... that's our
1120 : : // caller's problem. All we know is that the match failed.
1121 [ + + - + ]: 8 : Py_XDECREF(match_args);
1122 [ + - ]: 8 : Py_DECREF(seen);
1123 [ + - ]: 8 : Py_DECREF(attrs);
1124 : 8 : return NULL;
1125 : : }
1126 : :
1127 : :
1128 : : static int do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause);
1129 : : static int exception_group_match(
1130 : : PyObject* exc_value, PyObject *match_type,
1131 : : PyObject **match, PyObject **rest);
1132 : :
1133 : : static int unpack_iterable(PyThreadState *, PyObject *, int, int, PyObject **);
1134 : :
1135 : : PyObject *
1136 : 316399 : PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
1137 : : {
1138 : 316399 : PyThreadState *tstate = _PyThreadState_GET();
1139 [ - + ]: 316399 : if (locals == NULL) {
1140 : 0 : locals = globals;
1141 : : }
1142 : 316399 : PyObject *builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref
1143 [ - + ]: 316399 : if (builtins == NULL) {
1144 : 0 : return NULL;
1145 : : }
1146 : 316399 : PyFrameConstructor desc = {
1147 : : .fc_globals = globals,
1148 : : .fc_builtins = builtins,
1149 : 316399 : .fc_name = ((PyCodeObject *)co)->co_name,
1150 : 316399 : .fc_qualname = ((PyCodeObject *)co)->co_name,
1151 : : .fc_code = co,
1152 : : .fc_defaults = NULL,
1153 : : .fc_kwdefaults = NULL,
1154 : : .fc_closure = NULL
1155 : : };
1156 : 316399 : PyFunctionObject *func = _PyFunction_FromConstructor(&desc);
1157 [ - + ]: 316399 : if (func == NULL) {
1158 : 0 : return NULL;
1159 : : }
1160 : : EVAL_CALL_STAT_INC(EVAL_CALL_LEGACY);
1161 : 316399 : PyObject *res = _PyEval_Vector(tstate, func, locals, NULL, 0, NULL);
1162 [ + + ]: 316397 : Py_DECREF(func);
1163 : 316397 : return res;
1164 : : }
1165 : :
1166 : :
1167 : : /* Interpreter main loop */
1168 : :
1169 : : PyObject *
1170 : 0 : PyEval_EvalFrame(PyFrameObject *f)
1171 : : {
1172 : : /* Function kept for backward compatibility */
1173 : 0 : PyThreadState *tstate = _PyThreadState_GET();
1174 : 0 : return _PyEval_EvalFrame(tstate, f->f_frame, 0);
1175 : : }
1176 : :
1177 : : PyObject *
1178 : 0 : PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
1179 : : {
1180 : 0 : PyThreadState *tstate = _PyThreadState_GET();
1181 : 0 : return _PyEval_EvalFrame(tstate, f->f_frame, throwflag);
1182 : : }
1183 : :
1184 : :
1185 : : /* Handle signals, pending calls, GIL drop request
1186 : : and asynchronous exception */
1187 : : static int
1188 : 66607 : eval_frame_handle_pending(PyThreadState *tstate)
1189 : : {
1190 : 66607 : _PyRuntimeState * const runtime = &_PyRuntime;
1191 : 66607 : struct _ceval_runtime_state *ceval = &runtime->ceval;
1192 : :
1193 : : /* Pending signals */
1194 [ + + ]: 66607 : if (_Py_atomic_load_relaxed_int32(&ceval->signals_pending)) {
1195 [ + + ]: 31274 : if (handle_signals(tstate) != 0) {
1196 : 10 : return -1;
1197 : : }
1198 : : }
1199 : :
1200 : : /* Pending calls */
1201 : 66597 : struct _ceval_state *ceval2 = &tstate->interp->ceval;
1202 [ + + ]: 66597 : if (_Py_atomic_load_relaxed_int32(&ceval2->pending.calls_to_do)) {
1203 [ - + ]: 79 : if (make_pending_calls(tstate->interp) != 0) {
1204 : 0 : return -1;
1205 : : }
1206 : : }
1207 : :
1208 : : /* GIL drop request */
1209 [ + + ]: 66597 : if (_Py_atomic_load_relaxed_int32(&ceval2->gil_drop_request)) {
1210 : : /* Give another thread a chance */
1211 [ - + ]: 35314 : if (_PyThreadState_Swap(&runtime->gilstate, NULL) != tstate) {
1212 : : Py_FatalError("tstate mix-up");
1213 : : }
1214 : 35314 : drop_gil(ceval, ceval2, tstate);
1215 : :
1216 : : /* Other threads may run now */
1217 : :
1218 : 35314 : take_gil(tstate);
1219 : :
1220 [ - + ]: 35312 : if (_PyThreadState_Swap(&runtime->gilstate, tstate) != NULL) {
1221 : : Py_FatalError("orphan tstate");
1222 : : }
1223 : : }
1224 : :
1225 : : /* Check for asynchronous exception. */
1226 [ + + ]: 66595 : if (tstate->async_exc != NULL) {
1227 : 2 : PyObject *exc = tstate->async_exc;
1228 : 2 : tstate->async_exc = NULL;
1229 : 2 : UNSIGNAL_ASYNC_EXC(tstate->interp);
1230 : 2 : _PyErr_SetNone(tstate, exc);
1231 [ - + ]: 2 : Py_DECREF(exc);
1232 : 2 : return -1;
1233 : : }
1234 : :
1235 : : #ifdef MS_WINDOWS
1236 : : // bpo-42296: On Windows, _PyEval_SignalReceived() can be called in a
1237 : : // different thread than the Python thread, in which case
1238 : : // _Py_ThreadCanHandleSignals() is wrong. Recompute eval_breaker in the
1239 : : // current Python thread with the correct _Py_ThreadCanHandleSignals()
1240 : : // value. It prevents to interrupt the eval loop at every instruction if
1241 : : // the current Python thread cannot handle signals (if
1242 : : // _Py_ThreadCanHandleSignals() is false).
1243 : : COMPUTE_EVAL_BREAKER(tstate->interp, ceval, ceval2);
1244 : : #endif
1245 : :
1246 : 66593 : return 0;
1247 : : }
1248 : :
1249 : :
1250 : : /* Computed GOTOs, or
1251 : : the-optimization-commonly-but-improperly-known-as-"threaded code"
1252 : : using gcc's labels-as-values extension
1253 : : (http://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html).
1254 : :
1255 : : The traditional bytecode evaluation loop uses a "switch" statement, which
1256 : : decent compilers will optimize as a single indirect branch instruction
1257 : : combined with a lookup table of jump addresses. However, since the
1258 : : indirect jump instruction is shared by all opcodes, the CPU will have a
1259 : : hard time making the right prediction for where to jump next (actually,
1260 : : it will be always wrong except in the uncommon case of a sequence of
1261 : : several identical opcodes).
1262 : :
1263 : : "Threaded code" in contrast, uses an explicit jump table and an explicit
1264 : : indirect jump instruction at the end of each opcode. Since the jump
1265 : : instruction is at a different address for each opcode, the CPU will make a
1266 : : separate prediction for each of these instructions, which is equivalent to
1267 : : predicting the second opcode of each opcode pair. These predictions have
1268 : : a much better chance to turn out valid, especially in small bytecode loops.
1269 : :
1270 : : A mispredicted branch on a modern CPU flushes the whole pipeline and
1271 : : can cost several CPU cycles (depending on the pipeline depth),
1272 : : and potentially many more instructions (depending on the pipeline width).
1273 : : A correctly predicted branch, however, is nearly free.
1274 : :
1275 : : At the time of this writing, the "threaded code" version is up to 15-20%
1276 : : faster than the normal "switch" version, depending on the compiler and the
1277 : : CPU architecture.
1278 : :
1279 : : NOTE: care must be taken that the compiler doesn't try to "optimize" the
1280 : : indirect jumps by sharing them between all opcodes. Such optimizations
1281 : : can be disabled on gcc by using the -fno-gcse flag (or possibly
1282 : : -fno-crossjumping).
1283 : : */
1284 : :
1285 : : /* Use macros rather than inline functions, to make it as clear as possible
1286 : : * to the C compiler that the tracing check is a simple test then branch.
1287 : : * We want to be sure that the compiler knows this before it generates
1288 : : * the CFG.
1289 : : */
1290 : :
1291 : : #ifdef WITH_DTRACE
1292 : : #define OR_DTRACE_LINE | (PyDTrace_LINE_ENABLED() ? 255 : 0)
1293 : : #else
1294 : : #define OR_DTRACE_LINE
1295 : : #endif
1296 : :
1297 : : #ifdef HAVE_COMPUTED_GOTOS
1298 : : #ifndef USE_COMPUTED_GOTOS
1299 : : #define USE_COMPUTED_GOTOS 1
1300 : : #endif
1301 : : #else
1302 : : #if defined(USE_COMPUTED_GOTOS) && USE_COMPUTED_GOTOS
1303 : : #error "Computed gotos are not supported on this compiler."
1304 : : #endif
1305 : : #undef USE_COMPUTED_GOTOS
1306 : : #define USE_COMPUTED_GOTOS 0
1307 : : #endif
1308 : :
1309 : : #ifdef Py_STATS
1310 : : #define INSTRUCTION_START(op) \
1311 : : do { \
1312 : : frame->prev_instr = next_instr++; \
1313 : : OPCODE_EXE_INC(op); \
1314 : : if (_py_stats) _py_stats->opcode_stats[lastopcode].pair_count[op]++; \
1315 : : lastopcode = op; \
1316 : : } while (0)
1317 : : #else
1318 : : #define INSTRUCTION_START(op) (frame->prev_instr = next_instr++)
1319 : : #endif
1320 : :
1321 : : #if USE_COMPUTED_GOTOS
1322 : : #define TARGET(op) TARGET_##op: INSTRUCTION_START(op);
1323 : : #define DISPATCH_GOTO() goto *opcode_targets[opcode]
1324 : : #else
1325 : : #define TARGET(op) case op: INSTRUCTION_START(op);
1326 : : #define DISPATCH_GOTO() goto dispatch_opcode
1327 : : #endif
1328 : :
1329 : : /* PRE_DISPATCH_GOTO() does lltrace if enabled. Normally a no-op */
1330 : : #ifdef LLTRACE
1331 : : #define PRE_DISPATCH_GOTO() if (lltrace) { \
1332 : : lltrace_instruction(frame, stack_pointer, next_instr); }
1333 : : #else
1334 : : #define PRE_DISPATCH_GOTO() ((void)0)
1335 : : #endif
1336 : :
1337 : : #define NOTRACE_DISPATCH() \
1338 : : { \
1339 : : NEXTOPARG(); \
1340 : : PRE_DISPATCH_GOTO(); \
1341 : : DISPATCH_GOTO(); \
1342 : : }
1343 : :
1344 : : /* Do interpreter dispatch accounting for tracing and instrumentation */
1345 : : #define DISPATCH() \
1346 : : { \
1347 : : NEXTOPARG(); \
1348 : : PRE_DISPATCH_GOTO(); \
1349 : : assert(cframe.use_tracing == 0 || cframe.use_tracing == 255); \
1350 : : opcode |= cframe.use_tracing OR_DTRACE_LINE; \
1351 : : DISPATCH_GOTO(); \
1352 : : }
1353 : :
1354 : : #define NOTRACE_DISPATCH_SAME_OPARG() \
1355 : : { \
1356 : : opcode = _Py_OPCODE(*next_instr); \
1357 : : PRE_DISPATCH_GOTO(); \
1358 : : DISPATCH_GOTO(); \
1359 : : }
1360 : :
1361 : : #define CHECK_EVAL_BREAKER() \
1362 : : _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); \
1363 : : if (_Py_atomic_load_relaxed_int32(eval_breaker)) { \
1364 : : goto handle_eval_breaker; \
1365 : : }
1366 : :
1367 : :
1368 : : /* Tuple access macros */
1369 : :
1370 : : #ifndef Py_DEBUG
1371 : : #define GETITEM(v, i) PyTuple_GET_ITEM((PyTupleObject *)(v), (i))
1372 : : #else
1373 : : #define GETITEM(v, i) PyTuple_GetItem((v), (i))
1374 : : #endif
1375 : :
1376 : : /* Code access macros */
1377 : :
1378 : : /* The integer overflow is checked by an assertion below. */
1379 : : #define INSTR_OFFSET() ((int)(next_instr - first_instr))
1380 : : #define NEXTOPARG() do { \
1381 : : _Py_CODEUNIT word = *next_instr; \
1382 : : opcode = _Py_OPCODE(word); \
1383 : : oparg = _Py_OPARG(word); \
1384 : : } while (0)
1385 : : #define JUMPTO(x) (next_instr = first_instr + (x))
1386 : : #define JUMPBY(x) (next_instr += (x))
1387 : :
1388 : : /* Get opcode and oparg from original instructions, not quickened form. */
1389 : : #define TRACING_NEXTOPARG() do { \
1390 : : NEXTOPARG(); \
1391 : : opcode = _PyOpcode_Deopt[opcode]; \
1392 : : } while (0)
1393 : :
1394 : : /* OpCode prediction macros
1395 : : Some opcodes tend to come in pairs thus making it possible to
1396 : : predict the second code when the first is run. For example,
1397 : : COMPARE_OP is often followed by POP_JUMP_IF_FALSE or POP_JUMP_IF_TRUE.
1398 : :
1399 : : Verifying the prediction costs a single high-speed test of a register
1400 : : variable against a constant. If the pairing was good, then the
1401 : : processor's own internal branch predication has a high likelihood of
1402 : : success, resulting in a nearly zero-overhead transition to the
1403 : : next opcode. A successful prediction saves a trip through the eval-loop
1404 : : including its unpredictable switch-case branch. Combined with the
1405 : : processor's internal branch prediction, a successful PREDICT has the
1406 : : effect of making the two opcodes run as if they were a single new opcode
1407 : : with the bodies combined.
1408 : :
1409 : : If collecting opcode statistics, your choices are to either keep the
1410 : : predictions turned-on and interpret the results as if some opcodes
1411 : : had been combined or turn-off predictions so that the opcode frequency
1412 : : counter updates for both opcodes.
1413 : :
1414 : : Opcode prediction is disabled with threaded code, since the latter allows
1415 : : the CPU to record separate branch prediction information for each
1416 : : opcode.
1417 : :
1418 : : */
1419 : :
1420 : : #define PREDICT_ID(op) PRED_##op
1421 : :
1422 : : #if USE_COMPUTED_GOTOS
1423 : : #define PREDICT(op) if (0) goto PREDICT_ID(op)
1424 : : #else
1425 : : #define PREDICT(op) \
1426 : : do { \
1427 : : _Py_CODEUNIT word = *next_instr; \
1428 : : opcode = _Py_OPCODE(word) | cframe.use_tracing OR_DTRACE_LINE; \
1429 : : if (opcode == op) { \
1430 : : oparg = _Py_OPARG(word); \
1431 : : INSTRUCTION_START(op); \
1432 : : goto PREDICT_ID(op); \
1433 : : } \
1434 : : } while(0)
1435 : : #endif
1436 : : #define PREDICTED(op) PREDICT_ID(op):
1437 : :
1438 : :
1439 : : /* Stack manipulation macros */
1440 : :
1441 : : /* The stack can grow at most MAXINT deep, as co_nlocals and
1442 : : co_stacksize are ints. */
1443 : : #define STACK_LEVEL() ((int)(stack_pointer - _PyFrame_Stackbase(frame)))
1444 : : #define STACK_SIZE() (frame->f_code->co_stacksize)
1445 : : #define EMPTY() (STACK_LEVEL() == 0)
1446 : : #define TOP() (stack_pointer[-1])
1447 : : #define SECOND() (stack_pointer[-2])
1448 : : #define THIRD() (stack_pointer[-3])
1449 : : #define FOURTH() (stack_pointer[-4])
1450 : : #define PEEK(n) (stack_pointer[-(n)])
1451 : : #define SET_TOP(v) (stack_pointer[-1] = (v))
1452 : : #define SET_SECOND(v) (stack_pointer[-2] = (v))
1453 : : #define BASIC_STACKADJ(n) (stack_pointer += n)
1454 : : #define BASIC_PUSH(v) (*stack_pointer++ = (v))
1455 : : #define BASIC_POP() (*--stack_pointer)
1456 : :
1457 : : #ifdef Py_DEBUG
1458 : : #define PUSH(v) do { \
1459 : : BASIC_PUSH(v); \
1460 : : assert(STACK_LEVEL() <= STACK_SIZE()); \
1461 : : } while (0)
1462 : : #define POP() (assert(STACK_LEVEL() > 0), BASIC_POP())
1463 : : #define STACK_GROW(n) do { \
1464 : : assert(n >= 0); \
1465 : : BASIC_STACKADJ(n); \
1466 : : assert(STACK_LEVEL() <= STACK_SIZE()); \
1467 : : } while (0)
1468 : : #define STACK_SHRINK(n) do { \
1469 : : assert(n >= 0); \
1470 : : assert(STACK_LEVEL() >= n); \
1471 : : BASIC_STACKADJ(-(n)); \
1472 : : } while (0)
1473 : : #else
1474 : : #define PUSH(v) BASIC_PUSH(v)
1475 : : #define POP() BASIC_POP()
1476 : : #define STACK_GROW(n) BASIC_STACKADJ(n)
1477 : : #define STACK_SHRINK(n) BASIC_STACKADJ(-(n))
1478 : : #endif
1479 : :
1480 : : /* Local variable macros */
1481 : :
1482 : : #define GETLOCAL(i) (frame->localsplus[i])
1483 : :
1484 : : /* The SETLOCAL() macro must not DECREF the local variable in-place and
1485 : : then store the new value; it must copy the old value to a temporary
1486 : : value, then store the new value, and then DECREF the temporary value.
1487 : : This is because it is possible that during the DECREF the frame is
1488 : : accessed by other code (e.g. a __del__ method or gc.collect()) and the
1489 : : variable would be pointing to already-freed memory. */
1490 : : #define SETLOCAL(i, value) do { PyObject *tmp = GETLOCAL(i); \
1491 : : GETLOCAL(i) = value; \
1492 : : Py_XDECREF(tmp); } while (0)
1493 : :
1494 : : #define JUMP_TO_INSTRUCTION(op) goto PREDICT_ID(op)
1495 : :
1496 : :
1497 : : #define DEOPT_IF(cond, instname) if (cond) { goto miss; }
1498 : :
1499 : :
1500 : : #define GLOBALS() frame->f_globals
1501 : : #define BUILTINS() frame->f_builtins
1502 : : #define LOCALS() frame->f_locals
1503 : :
1504 : : /* Shared opcode macros */
1505 : :
1506 : : #define TRACE_FUNCTION_EXIT() \
1507 : : if (cframe.use_tracing) { \
1508 : : if (trace_function_exit(tstate, frame, retval)) { \
1509 : : Py_DECREF(retval); \
1510 : : goto exit_unwind; \
1511 : : } \
1512 : : }
1513 : :
1514 : : #define DTRACE_FUNCTION_EXIT() \
1515 : : if (PyDTrace_FUNCTION_RETURN_ENABLED()) { \
1516 : : dtrace_function_return(frame); \
1517 : : }
1518 : :
1519 : : #define TRACE_FUNCTION_UNWIND() \
1520 : : if (cframe.use_tracing) { \
1521 : : /* Since we are already unwinding, \
1522 : : * we don't care if this raises */ \
1523 : : trace_function_exit(tstate, frame, NULL); \
1524 : : }
1525 : :
1526 : : #define TRACE_FUNCTION_ENTRY() \
1527 : : if (cframe.use_tracing) { \
1528 : : _PyFrame_SetStackPointer(frame, stack_pointer); \
1529 : : int err = trace_function_entry(tstate, frame); \
1530 : : stack_pointer = _PyFrame_GetStackPointer(frame); \
1531 : : if (err) { \
1532 : : goto error; \
1533 : : } \
1534 : : }
1535 : :
1536 : : #define TRACE_FUNCTION_THROW_ENTRY() \
1537 : : if (cframe.use_tracing) { \
1538 : : assert(frame->stacktop >= 0); \
1539 : : if (trace_function_entry(tstate, frame)) { \
1540 : : goto exit_unwind; \
1541 : : } \
1542 : : }
1543 : :
1544 : : #define DTRACE_FUNCTION_ENTRY() \
1545 : : if (PyDTrace_FUNCTION_ENTRY_ENABLED()) { \
1546 : : dtrace_function_entry(frame); \
1547 : : }
1548 : :
1549 : : #define ADAPTIVE_COUNTER_IS_ZERO(cache) \
1550 : : (cache)->counter < (1<<ADAPTIVE_BACKOFF_BITS)
1551 : :
1552 : : #define DECREMENT_ADAPTIVE_COUNTER(cache) \
1553 : : (cache)->counter -= (1<<ADAPTIVE_BACKOFF_BITS)
1554 : :
1555 : : static int
1556 : 136592 : trace_function_entry(PyThreadState *tstate, _PyInterpreterFrame *frame)
1557 : : {
1558 [ + + ]: 136592 : if (tstate->c_tracefunc != NULL) {
1559 : : /* tstate->c_tracefunc, if defined, is a
1560 : : function that will be called on *every* entry
1561 : : to a code block. Its return value, if not
1562 : : None, is a function that will be called at
1563 : : the start of each executed line of code.
1564 : : (Actually, the function must return itself
1565 : : in order to continue tracing.) The trace
1566 : : functions are called with three arguments:
1567 : : a pointer to the current frame, a string
1568 : : indicating why the function is called, and
1569 : : an argument which depends on the situation.
1570 : : The global trace function is also called
1571 : : whenever an exception is detected. */
1572 [ + + ]: 134769 : if (call_trace_protected(tstate->c_tracefunc,
1573 : : tstate->c_traceobj,
1574 : : tstate, frame,
1575 : : PyTrace_CALL, Py_None)) {
1576 : : /* Trace function raised an error */
1577 : 1003 : return -1;
1578 : : }
1579 : : }
1580 [ + + ]: 135589 : if (tstate->c_profilefunc != NULL) {
1581 : : /* Similar for c_profilefunc, except it needn't
1582 : : return itself and isn't called for "line" events */
1583 [ - + ]: 1823 : if (call_trace_protected(tstate->c_profilefunc,
1584 : : tstate->c_profileobj,
1585 : : tstate, frame,
1586 : : PyTrace_CALL, Py_None)) {
1587 : : /* Profile function raised an error */
1588 : 0 : return -1;
1589 : : }
1590 : : }
1591 : 135589 : return 0;
1592 : : }
1593 : :
1594 : : static int
1595 : 2474668 : trace_function_exit(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObject *retval)
1596 : : {
1597 [ + + ]: 2474668 : if (tstate->c_tracefunc) {
1598 [ + + ]: 2462261 : if (call_trace_protected(tstate->c_tracefunc, tstate->c_traceobj,
1599 : : tstate, frame, PyTrace_RETURN, retval)) {
1600 : 1008 : return -1;
1601 : : }
1602 : : }
1603 [ + + ]: 2473660 : if (tstate->c_profilefunc) {
1604 [ - + ]: 12407 : if (call_trace_protected(tstate->c_profilefunc, tstate->c_profileobj,
1605 : : tstate, frame, PyTrace_RETURN, retval)) {
1606 : 0 : return -1;
1607 : : }
1608 : : }
1609 : 2473660 : return 0;
1610 : : }
1611 : :
1612 : : static _PyInterpreterFrame *
1613 : 183100203 : pop_frame(PyThreadState *tstate, _PyInterpreterFrame *frame)
1614 : : {
1615 : 183100203 : _PyInterpreterFrame *prev_frame = frame->previous;
1616 : 183100203 : _PyEvalFrameClearAndPop(tstate, frame);
1617 : 183100203 : return prev_frame;
1618 : : }
1619 : :
1620 : : /* It is only between the KW_NAMES instruction and the following CALL,
1621 : : * that this has any meaning.
1622 : : */
1623 : : typedef struct {
1624 : : PyObject *kwnames;
1625 : : } CallShape;
1626 : :
1627 : : // GH-89279: Must be a macro to be sure it's inlined by MSVC.
1628 : : #define is_method(stack_pointer, args) (PEEK((args)+2) != NULL)
1629 : :
1630 : : #define KWNAMES_LEN() \
1631 : : (call_shape.kwnames == NULL ? 0 : ((int)PyTuple_GET_SIZE(call_shape.kwnames)))
1632 : :
1633 : : PyObject* _Py_HOT_FUNCTION
1634 : 133082465 : _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag)
1635 : : {
1636 : 133082465 : _Py_EnsureTstateNotNULL(tstate);
1637 : : CALL_STAT_INC(pyeval_calls);
1638 : :
1639 : : #if USE_COMPUTED_GOTOS
1640 : : /* Import the static jump table */
1641 : : #include "opcode_targets.h"
1642 : : #endif
1643 : :
1644 : : #ifdef Py_STATS
1645 : : int lastopcode = 0;
1646 : : #endif
1647 : : // opcode is an 8-bit value to improve the code generated by MSVC
1648 : : // for the big switch below (in combination with the EXTRA_CASES macro).
1649 : : uint8_t opcode; /* Current opcode */
1650 : : int oparg; /* Current opcode argument, if any */
1651 : 133082465 : _Py_atomic_int * const eval_breaker = &tstate->interp->ceval.eval_breaker;
1652 : : #ifdef LLTRACE
1653 : : int lltrace = 0;
1654 : : #endif
1655 : :
1656 : : _PyCFrame cframe;
1657 : : CallShape call_shape;
1658 : 133082465 : call_shape.kwnames = NULL; // Borrowed reference. Reset by CALL instructions.
1659 : :
1660 : : /* WARNING: Because the _PyCFrame lives on the C stack,
1661 : : * but can be accessed from a heap allocated object (tstate)
1662 : : * strict stack discipline must be maintained.
1663 : : */
1664 : 133082465 : _PyCFrame *prev_cframe = tstate->cframe;
1665 : 133082465 : cframe.use_tracing = prev_cframe->use_tracing;
1666 : 133082465 : cframe.previous = prev_cframe;
1667 : 133082465 : tstate->cframe = &cframe;
1668 : :
1669 : 133082465 : frame->is_entry = true;
1670 : : /* Push frame */
1671 : 133082465 : frame->previous = prev_cframe->current_frame;
1672 : 133082465 : cframe.current_frame = frame;
1673 : :
1674 : : /* support for generator.throw() */
1675 [ + + ]: 133082465 : if (throwflag) {
1676 [ - + ]: 616940 : if (_Py_EnterRecursiveCallTstate(tstate, "")) {
1677 : 0 : tstate->recursion_remaining--;
1678 : 0 : goto exit_unwind;
1679 : : }
1680 [ + + - + ]: 616940 : TRACE_FUNCTION_THROW_ENTRY();
1681 [ - + ]: 616940 : DTRACE_FUNCTION_ENTRY();
1682 : 616940 : goto resume_with_error;
1683 : : }
1684 : :
1685 : : /* Local "register" variables.
1686 : : * These are cached values from the frame and code object. */
1687 : :
1688 : : PyObject *names;
1689 : : PyObject *consts;
1690 : : _Py_CODEUNIT *first_instr;
1691 : : _Py_CODEUNIT *next_instr;
1692 : : PyObject **stack_pointer;
1693 : :
1694 : : /* Sets the above local variables from the frame */
1695 : : #define SET_LOCALS_FROM_FRAME() \
1696 : : { \
1697 : : PyCodeObject *co = frame->f_code; \
1698 : : names = co->co_names; \
1699 : : consts = co->co_consts; \
1700 : : first_instr = _PyCode_CODE(co); \
1701 : : } \
1702 : : assert(_PyInterpreterFrame_LASTI(frame) >= -1); \
1703 : : /* Jump back to the last instruction executed... */ \
1704 : : next_instr = frame->prev_instr + 1; \
1705 : : stack_pointer = _PyFrame_GetStackPointer(frame); \
1706 : : /* Set stackdepth to -1. \
1707 : : Update when returning or calling trace function. \
1708 : : Having stackdepth <= 0 ensures that invalid \
1709 : : values are not visible to the cycle GC. \
1710 : : We choose -1 rather than 0 to assist debugging. \
1711 : : */ \
1712 : : frame->stacktop = -1;
1713 : :
1714 : :
1715 : 132465525 : start_frame:
1716 [ + + ]: 331472979 : if (_Py_EnterRecursiveCallTstate(tstate, "")) {
1717 : 8263 : tstate->recursion_remaining--;
1718 : 8263 : goto exit_unwind;
1719 : : }
1720 : :
1721 : 331464716 : resume_frame:
1722 : 530000863 : SET_LOCALS_FROM_FRAME();
1723 : :
1724 : : #ifdef LLTRACE
1725 : : {
1726 : : int r = PyDict_Contains(GLOBALS(), &_Py_ID(__lltrace__));
1727 : : if (r < 0) {
1728 : : goto exit_unwind;
1729 : : }
1730 : : lltrace = r;
1731 : : }
1732 : : if (lltrace) {
1733 : : lltrace_resume_frame(frame);
1734 : : }
1735 : : #endif
1736 : :
1737 : : #ifdef Py_DEBUG
1738 : : /* _PyEval_EvalFrameDefault() must not be called with an exception set,
1739 : : because it can clear it (directly or indirectly) and so the
1740 : : caller loses its exception */
1741 : : assert(!_PyErr_Occurred(tstate));
1742 : : #endif
1743 : :
1744 : 530000863 : DISPATCH();
1745 : :
1746 : 66607 : handle_eval_breaker:
1747 : :
1748 : : /* Do periodic things, like check for signals and async I/0.
1749 : : * We need to do reasonably frequently, but not too frequently.
1750 : : * All loops should include a check of the eval breaker.
1751 : : * We also check on return from any builtin function.
1752 : : */
1753 [ + + ]: 66607 : if (eval_frame_handle_pending(tstate) != 0) {
1754 : 12 : goto error;
1755 : : }
1756 : 66593 : DISPATCH();
1757 : :
1758 : : {
1759 : : /* Start instructions */
1760 : : #if USE_COMPUTED_GOTOS
1761 : : {
1762 : : #else
1763 : : dispatch_opcode:
1764 : : switch (opcode) {
1765 : : #endif
1766 : :
1767 : : /* BEWARE!
1768 : : It is essential that any operation that fails must goto error
1769 : : and that all operation that succeed call DISPATCH() ! */
1770 : :
1771 : 42816448 : TARGET(NOP) {
1772 : 42816448 : DISPATCH();
1773 : : }
1774 : :
1775 : 9003598 : TARGET(RESUME) {
1776 : 9003598 : _PyCode_Warmup(frame->f_code);
1777 : 9003598 : JUMP_TO_INSTRUCTION(RESUME_QUICK);
1778 : : }
1779 : :
1780 : 305396795 : TARGET(RESUME_QUICK) {
1781 : 314400393 : PREDICTED(RESUME_QUICK);
1782 : : assert(tstate->cframe == &cframe);
1783 : : assert(frame == cframe.current_frame);
1784 [ + + + + ]: 314400393 : if (_Py_atomic_load_relaxed_int32(eval_breaker) && oparg < 2) {
1785 : 36456 : goto handle_eval_breaker;
1786 : : }
1787 : 314363937 : DISPATCH();
1788 : : }
1789 : :
1790 : 3905880 : TARGET(LOAD_CLOSURE) {
1791 : : /* We keep LOAD_CLOSURE so that the bytecode stays more readable. */
1792 : 3905880 : PyObject *value = GETLOCAL(oparg);
1793 [ - + ]: 3905880 : if (value == NULL) {
1794 : 0 : goto unbound_local_error;
1795 : : }
1796 : 3905880 : Py_INCREF(value);
1797 : 3905880 : PUSH(value);
1798 : 3905880 : DISPATCH();
1799 : : }
1800 : :
1801 : 3339640 : TARGET(LOAD_FAST_CHECK) {
1802 : 3339640 : PyObject *value = GETLOCAL(oparg);
1803 [ + + ]: 3339640 : if (value == NULL) {
1804 : 6 : goto unbound_local_error;
1805 : : }
1806 : 3339634 : Py_INCREF(value);
1807 : 3339634 : PUSH(value);
1808 : 3339634 : DISPATCH();
1809 : : }
1810 : :
1811 : 1101992939 : TARGET(LOAD_FAST) {
1812 : 1101992939 : PyObject *value = GETLOCAL(oparg);
1813 : : assert(value != NULL);
1814 : 1101992939 : Py_INCREF(value);
1815 : 1101992939 : PUSH(value);
1816 : 1101992939 : DISPATCH();
1817 : : }
1818 : :
1819 : 511101959 : TARGET(LOAD_CONST) {
1820 : 511101959 : PREDICTED(LOAD_CONST);
1821 : 511101959 : PyObject *value = GETITEM(consts, oparg);
1822 : 511101959 : Py_INCREF(value);
1823 : 511101959 : PUSH(value);
1824 : 511101959 : DISPATCH();
1825 : : }
1826 : :
1827 : 173431280 : TARGET(STORE_FAST) {
1828 : 173431280 : PyObject *value = POP();
1829 [ + + + + ]: 173431280 : SETLOCAL(oparg, value);
1830 : 173431280 : DISPATCH();
1831 : : }
1832 : :
1833 : 380076064 : TARGET(LOAD_FAST__LOAD_FAST) {
1834 : 380076064 : PyObject *value = GETLOCAL(oparg);
1835 : : assert(value != NULL);
1836 : 380076064 : NEXTOPARG();
1837 : 380076064 : next_instr++;
1838 : 380076064 : Py_INCREF(value);
1839 : 380076064 : PUSH(value);
1840 : 380076064 : value = GETLOCAL(oparg);
1841 : : assert(value != NULL);
1842 : 380076064 : Py_INCREF(value);
1843 : 380076064 : PUSH(value);
1844 : 380076064 : NOTRACE_DISPATCH();
1845 : : }
1846 : :
1847 : 174414420 : TARGET(LOAD_FAST__LOAD_CONST) {
1848 : 174414420 : PyObject *value = GETLOCAL(oparg);
1849 : : assert(value != NULL);
1850 : 174414420 : NEXTOPARG();
1851 : 174414420 : next_instr++;
1852 : 174414420 : Py_INCREF(value);
1853 : 174414420 : PUSH(value);
1854 : 174414420 : value = GETITEM(consts, oparg);
1855 : 174414420 : Py_INCREF(value);
1856 : 174414420 : PUSH(value);
1857 : 174414420 : NOTRACE_DISPATCH();
1858 : : }
1859 : :
1860 : 256404928 : TARGET(STORE_FAST__LOAD_FAST) {
1861 : 256404928 : PyObject *value = POP();
1862 [ + + + + ]: 256404928 : SETLOCAL(oparg, value);
1863 : 256404928 : NEXTOPARG();
1864 : 256404928 : next_instr++;
1865 : 256404928 : value = GETLOCAL(oparg);
1866 : : assert(value != NULL);
1867 : 256404928 : Py_INCREF(value);
1868 : 256404928 : PUSH(value);
1869 : 256404928 : NOTRACE_DISPATCH();
1870 : : }
1871 : :
1872 : 106977990 : TARGET(STORE_FAST__STORE_FAST) {
1873 : 106977990 : PyObject *value = POP();
1874 [ + + + + ]: 106977990 : SETLOCAL(oparg, value);
1875 : 106977990 : NEXTOPARG();
1876 : 106977990 : next_instr++;
1877 : 106977990 : value = POP();
1878 [ + + + + ]: 106977990 : SETLOCAL(oparg, value);
1879 : 106977990 : NOTRACE_DISPATCH();
1880 : : }
1881 : :
1882 : 71339170 : TARGET(LOAD_CONST__LOAD_FAST) {
1883 : 71339170 : PyObject *value = GETITEM(consts, oparg);
1884 : 71339170 : NEXTOPARG();
1885 : 71339170 : next_instr++;
1886 : 71339170 : Py_INCREF(value);
1887 : 71339170 : PUSH(value);
1888 : 71339170 : value = GETLOCAL(oparg);
1889 : : assert(value != NULL);
1890 : 71339170 : Py_INCREF(value);
1891 : 71339170 : PUSH(value);
1892 : 71339170 : NOTRACE_DISPATCH();
1893 : : }
1894 : :
1895 : 188517303 : TARGET(POP_TOP) {
1896 : 188517303 : PyObject *value = POP();
1897 [ + + ]: 188517303 : Py_DECREF(value);
1898 : 188517303 : DISPATCH();
1899 : : }
1900 : :
1901 : 99909745 : TARGET(PUSH_NULL) {
1902 : : /* Use BASIC_PUSH as NULL is not a valid object pointer */
1903 : 99909745 : BASIC_PUSH(NULL);
1904 : 99909745 : DISPATCH();
1905 : : }
1906 : :
1907 : 37 : TARGET(UNARY_POSITIVE) {
1908 : 37 : PyObject *value = TOP();
1909 : 37 : PyObject *res = PyNumber_Positive(value);
1910 [ + + ]: 37 : Py_DECREF(value);
1911 : 37 : SET_TOP(res);
1912 [ + + ]: 37 : if (res == NULL)
1913 : 3 : goto error;
1914 : 34 : DISPATCH();
1915 : : }
1916 : :
1917 : 1179277 : TARGET(UNARY_NEGATIVE) {
1918 : 1179277 : PyObject *value = TOP();
1919 : 1179277 : PyObject *res = PyNumber_Negative(value);
1920 [ + + ]: 1179277 : Py_DECREF(value);
1921 : 1179277 : SET_TOP(res);
1922 [ + + ]: 1179277 : if (res == NULL)
1923 : 6 : goto error;
1924 : 1179271 : DISPATCH();
1925 : : }
1926 : :
1927 : 970009 : TARGET(UNARY_NOT) {
1928 : 970009 : PyObject *value = TOP();
1929 : 970009 : int err = PyObject_IsTrue(value);
1930 [ + + ]: 970009 : Py_DECREF(value);
1931 [ + + ]: 970009 : if (err == 0) {
1932 : 568654 : Py_INCREF(Py_True);
1933 : 568654 : SET_TOP(Py_True);
1934 : 568654 : DISPATCH();
1935 : : }
1936 [ + + ]: 401355 : else if (err > 0) {
1937 : 401354 : Py_INCREF(Py_False);
1938 : 401354 : SET_TOP(Py_False);
1939 : 401354 : DISPATCH();
1940 : : }
1941 : 1 : STACK_SHRINK(1);
1942 : 1 : goto error;
1943 : : }
1944 : :
1945 : 727839 : TARGET(UNARY_INVERT) {
1946 : 727839 : PyObject *value = TOP();
1947 : 727839 : PyObject *res = PyNumber_Invert(value);
1948 [ + + ]: 727839 : Py_DECREF(value);
1949 : 727839 : SET_TOP(res);
1950 [ + + ]: 727839 : if (res == NULL)
1951 : 5 : goto error;
1952 : 727834 : DISPATCH();
1953 : : }
1954 : :
1955 : 6113701 : TARGET(BINARY_OP_MULTIPLY_INT) {
1956 : : assert(cframe.use_tracing == 0);
1957 : 6113701 : PyObject *left = SECOND();
1958 : 6113701 : PyObject *right = TOP();
1959 [ + + ]: 6113701 : DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
1960 [ + + ]: 6107111 : DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);
1961 : : STAT_INC(BINARY_OP, hit);
1962 : 6054856 : PyObject *prod = _PyLong_Multiply((PyLongObject *)left, (PyLongObject *)right);
1963 : 6054856 : SET_SECOND(prod);
1964 [ + + ]: 6054856 : _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
1965 [ + + ]: 6054856 : _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
1966 : 6054856 : STACK_SHRINK(1);
1967 [ - + ]: 6054856 : if (prod == NULL) {
1968 : 0 : goto error;
1969 : : }
1970 : 6054856 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
1971 : 6054856 : NOTRACE_DISPATCH();
1972 : : }
1973 : :
1974 : 35232476 : TARGET(BINARY_OP_MULTIPLY_FLOAT) {
1975 : : assert(cframe.use_tracing == 0);
1976 : 35232476 : PyObject *left = SECOND();
1977 : 35232476 : PyObject *right = TOP();
1978 [ + + ]: 35232476 : DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
1979 [ + + ]: 35232274 : DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);
1980 : : STAT_INC(BINARY_OP, hit);
1981 : 35230048 : double dprod = ((PyFloatObject *)left)->ob_fval *
1982 : 35230048 : ((PyFloatObject *)right)->ob_fval;
1983 : 35230048 : PyObject *prod = PyFloat_FromDouble(dprod);
1984 : 35230048 : SET_SECOND(prod);
1985 [ + + ]: 35230048 : _Py_DECREF_SPECIALIZED(right, _PyFloat_ExactDealloc);
1986 [ + + ]: 35230048 : _Py_DECREF_SPECIALIZED(left, _PyFloat_ExactDealloc);
1987 : 35230048 : STACK_SHRINK(1);
1988 [ - + ]: 35230048 : if (prod == NULL) {
1989 : 0 : goto error;
1990 : : }
1991 : 35230048 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
1992 : 35230048 : NOTRACE_DISPATCH();
1993 : : }
1994 : :
1995 : 20797132 : TARGET(BINARY_OP_SUBTRACT_INT) {
1996 : : assert(cframe.use_tracing == 0);
1997 : 20797132 : PyObject *left = SECOND();
1998 : 20797132 : PyObject *right = TOP();
1999 [ + + ]: 20797132 : DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
2000 [ - + ]: 20796849 : DEOPT_IF(!PyLong_CheckExact(right), BINARY_OP);
2001 : : STAT_INC(BINARY_OP, hit);
2002 : 20796849 : PyObject *sub = _PyLong_Subtract((PyLongObject *)left, (PyLongObject *)right);
2003 : 20796849 : SET_SECOND(sub);
2004 [ + + ]: 20796849 : _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
2005 [ + + ]: 20796849 : _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
2006 : 20796849 : STACK_SHRINK(1);
2007 [ - + ]: 20796849 : if (sub == NULL) {
2008 : 0 : goto error;
2009 : : }
2010 : 20796849 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
2011 : 20796849 : NOTRACE_DISPATCH();
2012 : : }
2013 : :
2014 : 8099089 : TARGET(BINARY_OP_SUBTRACT_FLOAT) {
2015 : : assert(cframe.use_tracing == 0);
2016 : 8099089 : PyObject *left = SECOND();
2017 : 8099089 : PyObject *right = TOP();
2018 [ + + ]: 8099089 : DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
2019 [ + + ]: 8098613 : DEOPT_IF(!PyFloat_CheckExact(right), BINARY_OP);
2020 : : STAT_INC(BINARY_OP, hit);
2021 : 8097455 : double dsub = ((PyFloatObject *)left)->ob_fval - ((PyFloatObject *)right)->ob_fval;
2022 : 8097455 : PyObject *sub = PyFloat_FromDouble(dsub);
2023 : 8097455 : SET_SECOND(sub);
2024 [ + + ]: 8097455 : _Py_DECREF_SPECIALIZED(right, _PyFloat_ExactDealloc);
2025 [ + + ]: 8097455 : _Py_DECREF_SPECIALIZED(left, _PyFloat_ExactDealloc);
2026 : 8097455 : STACK_SHRINK(1);
2027 [ - + ]: 8097455 : if (sub == NULL) {
2028 : 0 : goto error;
2029 : : }
2030 : 8097455 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
2031 : 8097455 : NOTRACE_DISPATCH();
2032 : : }
2033 : :
2034 : 25766297 : TARGET(BINARY_OP_ADD_UNICODE) {
2035 : : assert(cframe.use_tracing == 0);
2036 : 25766297 : PyObject *left = SECOND();
2037 : 25766297 : PyObject *right = TOP();
2038 [ + + ]: 25766297 : DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);
2039 [ + + ]: 25763823 : DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
2040 : : STAT_INC(BINARY_OP, hit);
2041 : 25763820 : PyObject *res = PyUnicode_Concat(left, right);
2042 : 25763820 : STACK_SHRINK(1);
2043 : 25763820 : SET_TOP(res);
2044 [ + + ]: 25763820 : _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);
2045 [ + + ]: 25763820 : _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
2046 [ - + ]: 25763820 : if (TOP() == NULL) {
2047 : 0 : goto error;
2048 : : }
2049 : 25763820 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
2050 : 25763820 : NOTRACE_DISPATCH();
2051 : : }
2052 : :
2053 : 3644658 : TARGET(BINARY_OP_INPLACE_ADD_UNICODE) {
2054 : : assert(cframe.use_tracing == 0);
2055 : 3644658 : PyObject *left = SECOND();
2056 : 3644658 : PyObject *right = TOP();
2057 [ + + ]: 3644658 : DEOPT_IF(!PyUnicode_CheckExact(left), BINARY_OP);
2058 [ + + ]: 3642239 : DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
2059 : 3642234 : _Py_CODEUNIT true_next = next_instr[INLINE_CACHE_ENTRIES_BINARY_OP];
2060 : : assert(_Py_OPCODE(true_next) == STORE_FAST ||
2061 : : _Py_OPCODE(true_next) == STORE_FAST__LOAD_FAST);
2062 : 3642234 : PyObject **target_local = &GETLOCAL(_Py_OPARG(true_next));
2063 [ + + ]: 3642234 : DEOPT_IF(*target_local != left, BINARY_OP);
2064 : : STAT_INC(BINARY_OP, hit);
2065 : : /* Handle `left = left + right` or `left += right` for str.
2066 : : *
2067 : : * When possible, extend `left` in place rather than
2068 : : * allocating a new PyUnicodeObject. This attempts to avoid
2069 : : * quadratic behavior when one neglects to use str.join().
2070 : : *
2071 : : * If `left` has only two references remaining (one from
2072 : : * the stack, one in the locals), DECREFing `left` leaves
2073 : : * only the locals reference, so PyUnicode_Append knows
2074 : : * that the string is safe to mutate.
2075 : : */
2076 : : assert(Py_REFCNT(left) >= 2);
2077 : 3641864 : _Py_DECREF_NO_DEALLOC(left);
2078 : 3641864 : STACK_SHRINK(2);
2079 : 3641864 : PyUnicode_Append(target_local, right);
2080 [ + + ]: 3641864 : _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
2081 [ - + ]: 3641864 : if (*target_local == NULL) {
2082 : 0 : goto error;
2083 : : }
2084 : : // The STORE_FAST is already done.
2085 : 3641864 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP + 1);
2086 : 3641864 : NOTRACE_DISPATCH();
2087 : : }
2088 : :
2089 : 19720646 : TARGET(BINARY_OP_ADD_FLOAT) {
2090 : : assert(cframe.use_tracing == 0);
2091 : 19720646 : PyObject *left = SECOND();
2092 : 19720646 : PyObject *right = TOP();
2093 [ + + ]: 19720646 : DEOPT_IF(!PyFloat_CheckExact(left), BINARY_OP);
2094 [ + + ]: 19718107 : DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
2095 : : STAT_INC(BINARY_OP, hit);
2096 : 19717519 : double dsum = ((PyFloatObject *)left)->ob_fval +
2097 : 19717519 : ((PyFloatObject *)right)->ob_fval;
2098 : 19717519 : PyObject *sum = PyFloat_FromDouble(dsum);
2099 : 19717519 : SET_SECOND(sum);
2100 [ + + ]: 19717519 : _Py_DECREF_SPECIALIZED(right, _PyFloat_ExactDealloc);
2101 [ + + ]: 19717519 : _Py_DECREF_SPECIALIZED(left, _PyFloat_ExactDealloc);
2102 : 19717519 : STACK_SHRINK(1);
2103 [ - + ]: 19717519 : if (sum == NULL) {
2104 : 0 : goto error;
2105 : : }
2106 : 19717519 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
2107 : 19717519 : NOTRACE_DISPATCH();
2108 : : }
2109 : :
2110 : 45998333 : TARGET(BINARY_OP_ADD_INT) {
2111 : : assert(cframe.use_tracing == 0);
2112 : 45998333 : PyObject *left = SECOND();
2113 : 45998333 : PyObject *right = TOP();
2114 [ + + ]: 45998333 : DEOPT_IF(!PyLong_CheckExact(left), BINARY_OP);
2115 [ + + ]: 45997443 : DEOPT_IF(Py_TYPE(right) != Py_TYPE(left), BINARY_OP);
2116 : : STAT_INC(BINARY_OP, hit);
2117 : 45982692 : PyObject *sum = _PyLong_Add((PyLongObject *)left, (PyLongObject *)right);
2118 : 45982692 : SET_SECOND(sum);
2119 [ + + ]: 45982692 : _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
2120 [ + + ]: 45982692 : _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
2121 : 45982692 : STACK_SHRINK(1);
2122 [ - + ]: 45982692 : if (sum == NULL) {
2123 : 0 : goto error;
2124 : : }
2125 : 45982692 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
2126 : 45982692 : NOTRACE_DISPATCH();
2127 : : }
2128 : :
2129 : 9473196 : TARGET(BINARY_SUBSCR) {
2130 : 76648330 : PREDICTED(BINARY_SUBSCR);
2131 : 76648330 : PyObject *sub = POP();
2132 : 76648330 : PyObject *container = TOP();
2133 : 76648330 : PyObject *res = PyObject_GetItem(container, sub);
2134 [ + + ]: 76648330 : Py_DECREF(container);
2135 [ + + ]: 76648330 : Py_DECREF(sub);
2136 : 76648330 : SET_TOP(res);
2137 [ + + ]: 76648330 : if (res == NULL)
2138 : 490027 : goto error;
2139 : 76158303 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
2140 : 76158303 : DISPATCH();
2141 : : }
2142 : :
2143 : 47957953 : TARGET(BINARY_SLICE) {
2144 : 47957953 : PyObject *stop = POP();
2145 : 47957953 : PyObject *start = POP();
2146 : 47957953 : PyObject *container = TOP();
2147 : :
2148 : 47957953 : PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);
2149 [ - + ]: 47957953 : if (slice == NULL) {
2150 : 0 : goto error;
2151 : : }
2152 : 47957953 : PyObject *res = PyObject_GetItem(container, slice);
2153 [ + + ]: 47957953 : Py_DECREF(slice);
2154 [ + + ]: 47957953 : if (res == NULL) {
2155 : 31 : goto error;
2156 : : }
2157 : 47957922 : SET_TOP(res);
2158 [ + + ]: 47957922 : Py_DECREF(container);
2159 : 47957922 : DISPATCH();
2160 : : }
2161 : :
2162 : 239109 : TARGET(STORE_SLICE) {
2163 : 239109 : PyObject *stop = POP();
2164 : 239109 : PyObject *start = POP();
2165 : 239109 : PyObject *container = TOP();
2166 : 239109 : PyObject *v = SECOND();
2167 : :
2168 : 239109 : PyObject *slice = _PyBuildSlice_ConsumeRefs(start, stop);
2169 [ - + ]: 239109 : if (slice == NULL) {
2170 : 0 : goto error;
2171 : : }
2172 : 239109 : int err = PyObject_SetItem(container, slice, v);
2173 [ + + ]: 239109 : Py_DECREF(slice);
2174 [ + + ]: 239109 : if (err) {
2175 : 23 : goto error;
2176 : : }
2177 : 239086 : STACK_SHRINK(2);
2178 [ + + ]: 239086 : Py_DECREF(v);
2179 [ + + ]: 239086 : Py_DECREF(container);
2180 : 239086 : DISPATCH();
2181 : : }
2182 : :
2183 : 67766777 : TARGET(BINARY_SUBSCR_ADAPTIVE) {
2184 : 67766777 : _PyBinarySubscrCache *cache = (_PyBinarySubscrCache *)next_instr;
2185 [ + + ]: 67766777 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
2186 : 591643 : PyObject *sub = TOP();
2187 : 591643 : PyObject *container = SECOND();
2188 : 591643 : next_instr--;
2189 [ - + ]: 591643 : if (_Py_Specialize_BinarySubscr(container, sub, next_instr) < 0) {
2190 : 0 : goto error;
2191 : : }
2192 : 591643 : NOTRACE_DISPATCH_SAME_OPARG();
2193 : : }
2194 : : else {
2195 : : STAT_INC(BINARY_SUBSCR, deferred);
2196 : 67175134 : DECREMENT_ADAPTIVE_COUNTER(cache);
2197 : 67175134 : JUMP_TO_INSTRUCTION(BINARY_SUBSCR);
2198 : : }
2199 : : }
2200 : :
2201 : 33818860 : TARGET(BINARY_SUBSCR_LIST_INT) {
2202 : : assert(cframe.use_tracing == 0);
2203 : 33818860 : PyObject *sub = TOP();
2204 : 33818860 : PyObject *list = SECOND();
2205 [ + + ]: 33818860 : DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
2206 [ + + ]: 33818810 : DEOPT_IF(!PyList_CheckExact(list), BINARY_SUBSCR);
2207 : :
2208 : : // Deopt unless 0 <= sub < PyList_Size(list)
2209 : 33694447 : Py_ssize_t signed_magnitude = Py_SIZE(sub);
2210 [ + + ]: 33694447 : DEOPT_IF(((size_t)signed_magnitude) > 1, BINARY_SUBSCR);
2211 : : assert(((PyLongObject *)_PyLong_GetZero())->ob_digit[0] == 0);
2212 : 27741121 : Py_ssize_t index = ((PyLongObject*)sub)->ob_digit[0];
2213 [ + + ]: 27741121 : DEOPT_IF(index >= PyList_GET_SIZE(list), BINARY_SUBSCR);
2214 : : STAT_INC(BINARY_SUBSCR, hit);
2215 : 27419760 : PyObject *res = PyList_GET_ITEM(list, index);
2216 : : assert(res != NULL);
2217 : 27419760 : Py_INCREF(res);
2218 : 27419760 : STACK_SHRINK(1);
2219 [ + + ]: 27419760 : _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
2220 : 27419760 : SET_TOP(res);
2221 [ + + ]: 27419760 : Py_DECREF(list);
2222 : 27419760 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
2223 : 27419760 : NOTRACE_DISPATCH();
2224 : : }
2225 : :
2226 : 16697448 : TARGET(BINARY_SUBSCR_TUPLE_INT) {
2227 : : assert(cframe.use_tracing == 0);
2228 : 16697448 : PyObject *sub = TOP();
2229 : 16697448 : PyObject *tuple = SECOND();
2230 [ + + ]: 16697448 : DEOPT_IF(!PyLong_CheckExact(sub), BINARY_SUBSCR);
2231 [ + + ]: 16697427 : DEOPT_IF(!PyTuple_CheckExact(tuple), BINARY_SUBSCR);
2232 : :
2233 : : // Deopt unless 0 <= sub < PyTuple_Size(list)
2234 : 16052057 : Py_ssize_t signed_magnitude = Py_SIZE(sub);
2235 [ + + ]: 16052057 : DEOPT_IF(((size_t)signed_magnitude) > 1, BINARY_SUBSCR);
2236 : : assert(((PyLongObject *)_PyLong_GetZero())->ob_digit[0] == 0);
2237 : 14870532 : Py_ssize_t index = ((PyLongObject*)sub)->ob_digit[0];
2238 [ + + ]: 14870532 : DEOPT_IF(index >= PyTuple_GET_SIZE(tuple), BINARY_SUBSCR);
2239 : : STAT_INC(BINARY_SUBSCR, hit);
2240 : 14870220 : PyObject *res = PyTuple_GET_ITEM(tuple, index);
2241 : : assert(res != NULL);
2242 : 14870220 : Py_INCREF(res);
2243 : 14870220 : STACK_SHRINK(1);
2244 [ - + ]: 14870220 : _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
2245 : 14870220 : SET_TOP(res);
2246 [ + + ]: 14870220 : Py_DECREF(tuple);
2247 : 14870220 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
2248 : 14870220 : NOTRACE_DISPATCH();
2249 : : }
2250 : :
2251 : 14840401 : TARGET(BINARY_SUBSCR_DICT) {
2252 : : assert(cframe.use_tracing == 0);
2253 : 14840401 : PyObject *dict = SECOND();
2254 [ + + ]: 14840401 : DEOPT_IF(!PyDict_CheckExact(SECOND()), BINARY_SUBSCR);
2255 : : STAT_INC(BINARY_SUBSCR, hit);
2256 : 14837896 : PyObject *sub = TOP();
2257 : 14837896 : PyObject *res = PyDict_GetItemWithError(dict, sub);
2258 [ + + ]: 14837896 : if (res == NULL) {
2259 : 710122 : goto binary_subscr_dict_error;
2260 : : }
2261 : 14127774 : Py_INCREF(res);
2262 : 14127774 : STACK_SHRINK(1);
2263 [ + + ]: 14127774 : Py_DECREF(sub);
2264 : 14127774 : SET_TOP(res);
2265 [ + + ]: 14127774 : Py_DECREF(dict);
2266 : 14127774 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
2267 : 14127774 : DISPATCH();
2268 : : }
2269 : :
2270 : 1704758 : TARGET(BINARY_SUBSCR_GETITEM) {
2271 : 1704758 : PyObject *sub = TOP();
2272 : 1704758 : PyObject *container = SECOND();
2273 : 1704758 : _PyBinarySubscrCache *cache = (_PyBinarySubscrCache *)next_instr;
2274 : 1704758 : uint32_t type_version = read_u32(cache->type_version);
2275 : 1704758 : PyTypeObject *tp = Py_TYPE(container);
2276 [ + + ]: 1704758 : DEOPT_IF(tp->tp_version_tag != type_version, BINARY_SUBSCR);
2277 : : assert(tp->tp_flags & Py_TPFLAGS_HEAPTYPE);
2278 : 1700898 : PyObject *cached = ((PyHeapTypeObject *)tp)->_spec_cache.getitem;
2279 : : assert(PyFunction_Check(cached));
2280 : 1700898 : PyFunctionObject *getitem = (PyFunctionObject *)cached;
2281 [ - + ]: 1700898 : DEOPT_IF(getitem->func_version != cache->func_version, BINARY_SUBSCR);
2282 : 1700898 : PyCodeObject *code = (PyCodeObject *)getitem->func_code;
2283 : : assert(code->co_argcount == 2);
2284 [ + + ]: 1700898 : DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), BINARY_SUBSCR);
2285 : : STAT_INC(BINARY_SUBSCR, hit);
2286 : 1700872 : Py_INCREF(getitem);
2287 : 1700872 : _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, getitem);
2288 : : CALL_STAT_INC(inlined_py_calls);
2289 : 1700872 : STACK_SHRINK(2);
2290 : 1700872 : new_frame->localsplus[0] = container;
2291 : 1700872 : new_frame->localsplus[1] = sub;
2292 [ + + ]: 1898732 : for (int i = 2; i < code->co_nlocalsplus; i++) {
2293 : 197860 : new_frame->localsplus[i] = NULL;
2294 : : }
2295 : 1700872 : _PyFrame_SetStackPointer(frame, stack_pointer);
2296 : 1700872 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_SUBSCR);
2297 : 1700872 : frame->prev_instr = next_instr - 1;
2298 : 1700872 : new_frame->previous = frame;
2299 : 1700872 : frame = cframe.current_frame = new_frame;
2300 : : CALL_STAT_INC(inlined_py_calls);
2301 : 1700872 : goto start_frame;
2302 : : }
2303 : :
2304 : 29239013 : TARGET(LIST_APPEND) {
2305 : 29239013 : PyObject *v = POP();
2306 : 29239013 : PyObject *list = PEEK(oparg);
2307 [ - + ]: 29239013 : if (_PyList_AppendTakeRef((PyListObject *)list, v) < 0)
2308 : 0 : goto error;
2309 : : PREDICT(JUMP_BACKWARD_QUICK);
2310 : 29239013 : DISPATCH();
2311 : : }
2312 : :
2313 : 1295971 : TARGET(SET_ADD) {
2314 : 1295971 : PyObject *v = POP();
2315 : 1295971 : PyObject *set = PEEK(oparg);
2316 : : int err;
2317 : 1295971 : err = PySet_Add(set, v);
2318 [ + + ]: 1295971 : Py_DECREF(v);
2319 [ - + ]: 1295971 : if (err != 0)
2320 : 0 : goto error;
2321 : : PREDICT(JUMP_BACKWARD_QUICK);
2322 : 1295971 : DISPATCH();
2323 : : }
2324 : :
2325 : 1295946 : TARGET(STORE_SUBSCR) {
2326 : 9394767 : PREDICTED(STORE_SUBSCR);
2327 : 9394767 : PyObject *sub = TOP();
2328 : 9394767 : PyObject *container = SECOND();
2329 : 9394767 : PyObject *v = THIRD();
2330 : : int err;
2331 : 9394767 : STACK_SHRINK(3);
2332 : : /* container[sub] = v */
2333 : 9394767 : err = PyObject_SetItem(container, sub, v);
2334 [ + + ]: 9394767 : Py_DECREF(v);
2335 [ + + ]: 9394767 : Py_DECREF(container);
2336 [ + + ]: 9394767 : Py_DECREF(sub);
2337 [ + + ]: 9394767 : if (err != 0) {
2338 : 9370 : goto error;
2339 : : }
2340 : 9385397 : JUMPBY(INLINE_CACHE_ENTRIES_STORE_SUBSCR);
2341 : 9385397 : DISPATCH();
2342 : : }
2343 : :
2344 : 8373856 : TARGET(STORE_SUBSCR_ADAPTIVE) {
2345 : 8373856 : _PyStoreSubscrCache *cache = (_PyStoreSubscrCache *)next_instr;
2346 [ + + ]: 8373856 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
2347 : 275035 : PyObject *sub = TOP();
2348 : 275035 : PyObject *container = SECOND();
2349 : 275035 : next_instr--;
2350 [ - + ]: 275035 : if (_Py_Specialize_StoreSubscr(container, sub, next_instr) < 0) {
2351 : 0 : goto error;
2352 : : }
2353 : 275035 : NOTRACE_DISPATCH_SAME_OPARG();
2354 : : }
2355 : : else {
2356 : : STAT_INC(STORE_SUBSCR, deferred);
2357 : 8098821 : DECREMENT_ADAPTIVE_COUNTER(cache);
2358 : 8098821 : JUMP_TO_INSTRUCTION(STORE_SUBSCR);
2359 : : }
2360 : : }
2361 : :
2362 : 4875774 : TARGET(STORE_SUBSCR_LIST_INT) {
2363 : : assert(cframe.use_tracing == 0);
2364 : 4875774 : PyObject *sub = TOP();
2365 : 4875774 : PyObject *list = SECOND();
2366 : 4875774 : PyObject *value = THIRD();
2367 [ - + ]: 4875774 : DEOPT_IF(!PyLong_CheckExact(sub), STORE_SUBSCR);
2368 [ + + ]: 4875774 : DEOPT_IF(!PyList_CheckExact(list), STORE_SUBSCR);
2369 : :
2370 : : // Ensure nonnegative, zero-or-one-digit ints.
2371 [ + + ]: 4875772 : DEOPT_IF(((size_t)Py_SIZE(sub)) > 1, STORE_SUBSCR);
2372 : 4875399 : Py_ssize_t index = ((PyLongObject*)sub)->ob_digit[0];
2373 : : // Ensure index < len(list)
2374 [ - + ]: 4875399 : DEOPT_IF(index >= PyList_GET_SIZE(list), STORE_SUBSCR);
2375 : : STAT_INC(STORE_SUBSCR, hit);
2376 : :
2377 : 4875399 : PyObject *old_value = PyList_GET_ITEM(list, index);
2378 : 4875399 : PyList_SET_ITEM(list, index, value);
2379 : 4875399 : STACK_SHRINK(3);
2380 : : assert(old_value != NULL);
2381 [ + + ]: 4875399 : Py_DECREF(old_value);
2382 [ - + ]: 4875399 : _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);
2383 [ - + ]: 4875399 : Py_DECREF(list);
2384 : 4875399 : JUMPBY(INLINE_CACHE_ENTRIES_STORE_SUBSCR);
2385 : 4875399 : NOTRACE_DISPATCH();
2386 : : }
2387 : :
2388 : 11282631 : TARGET(STORE_SUBSCR_DICT) {
2389 : : assert(cframe.use_tracing == 0);
2390 : 11282631 : PyObject *sub = TOP();
2391 : 11282631 : PyObject *dict = SECOND();
2392 : 11282631 : PyObject *value = THIRD();
2393 [ + + ]: 11282631 : DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR);
2394 : 11282041 : STACK_SHRINK(3);
2395 : : STAT_INC(STORE_SUBSCR, hit);
2396 : 11282041 : int err = _PyDict_SetItem_Take2((PyDictObject *)dict, sub, value);
2397 [ - + ]: 11282041 : Py_DECREF(dict);
2398 [ + + ]: 11282041 : if (err != 0) {
2399 : 3 : goto error;
2400 : : }
2401 : 11282038 : JUMPBY(INLINE_CACHE_ENTRIES_STORE_SUBSCR);
2402 : 11282038 : DISPATCH();
2403 : : }
2404 : :
2405 : 1682758 : TARGET(DELETE_SUBSCR) {
2406 : 1682758 : PyObject *sub = TOP();
2407 : 1682758 : PyObject *container = SECOND();
2408 : : int err;
2409 : 1682758 : STACK_SHRINK(2);
2410 : : /* del container[sub] */
2411 : 1682758 : err = PyObject_DelItem(container, sub);
2412 [ + + ]: 1682758 : Py_DECREF(container);
2413 [ + + ]: 1682758 : Py_DECREF(sub);
2414 [ + + ]: 1682758 : if (err != 0)
2415 : 10182 : goto error;
2416 : 1672576 : DISPATCH();
2417 : : }
2418 : :
2419 : 3070 : TARGET(PRINT_EXPR) {
2420 : 3070 : PyObject *value = POP();
2421 : 3070 : PyObject *hook = _PySys_GetAttr(tstate, &_Py_ID(displayhook));
2422 : : PyObject *res;
2423 [ + + ]: 3070 : if (hook == NULL) {
2424 : 1 : _PyErr_SetString(tstate, PyExc_RuntimeError,
2425 : : "lost sys.displayhook");
2426 [ - + ]: 1 : Py_DECREF(value);
2427 : 1 : goto error;
2428 : : }
2429 : 3069 : res = PyObject_CallOneArg(hook, value);
2430 [ - + ]: 3069 : Py_DECREF(value);
2431 [ + + ]: 3069 : if (res == NULL)
2432 : 1 : goto error;
2433 [ - + ]: 3068 : Py_DECREF(res);
2434 : 3068 : DISPATCH();
2435 : : }
2436 : :
2437 : 355812 : TARGET(RAISE_VARARGS) {
2438 : 355812 : PyObject *cause = NULL, *exc = NULL;
2439 [ + + + - ]: 355812 : switch (oparg) {
2440 : 68009 : case 2:
2441 : 68009 : cause = POP(); /* cause */
2442 : : /* fall through */
2443 : 341750 : case 1:
2444 : 341750 : exc = POP(); /* exc */
2445 : : /* fall through */
2446 : 355812 : case 0:
2447 [ + + ]: 355812 : if (do_raise(tstate, exc, cause)) {
2448 : 14060 : goto exception_unwind;
2449 : : }
2450 : 341752 : break;
2451 : 0 : default:
2452 : 0 : _PyErr_SetString(tstate, PyExc_SystemError,
2453 : : "bad RAISE_VARARGS oparg");
2454 : 0 : break;
2455 : : }
2456 : 341752 : goto error;
2457 : : }
2458 : :
2459 : 268266799 : TARGET(RETURN_VALUE) {
2460 : 268266799 : PyObject *retval = POP();
2461 : : assert(EMPTY());
2462 : 268266799 : _PyFrame_SetStackPointer(frame, stack_pointer);
2463 [ + + + + : 268266799 : TRACE_FUNCTION_EXIT();
- + ]
2464 [ - + ]: 268265792 : DTRACE_FUNCTION_EXIT();
2465 : 268265792 : _Py_LeaveRecursiveCallTstate(tstate);
2466 [ + + ]: 268265792 : if (!frame->is_entry) {
2467 : 182629481 : frame = cframe.current_frame = pop_frame(tstate, frame);
2468 : 182629481 : _PyFrame_StackPush(frame, retval);
2469 : 182629481 : goto resume_frame;
2470 : : }
2471 : : /* Restore previous cframe and return. */
2472 : 85636311 : tstate->cframe = cframe.previous;
2473 : 85636311 : tstate->cframe->use_tracing = cframe.use_tracing;
2474 : : assert(tstate->cframe->current_frame == frame->previous);
2475 : : assert(!_PyErr_Occurred(tstate));
2476 : 85636311 : return retval;
2477 : : }
2478 : :
2479 : 158 : TARGET(GET_AITER) {
2480 : 158 : unaryfunc getter = NULL;
2481 : 158 : PyObject *iter = NULL;
2482 : 158 : PyObject *obj = TOP();
2483 : 158 : PyTypeObject *type = Py_TYPE(obj);
2484 : :
2485 [ + + ]: 158 : if (type->tp_as_async != NULL) {
2486 : 157 : getter = type->tp_as_async->am_aiter;
2487 : : }
2488 : :
2489 [ + + ]: 158 : if (getter != NULL) {
2490 : 157 : iter = (*getter)(obj);
2491 [ - + ]: 157 : Py_DECREF(obj);
2492 [ + + ]: 157 : if (iter == NULL) {
2493 : 2 : SET_TOP(NULL);
2494 : 2 : goto error;
2495 : : }
2496 : : }
2497 : : else {
2498 : 1 : SET_TOP(NULL);
2499 : 1 : _PyErr_Format(tstate, PyExc_TypeError,
2500 : : "'async for' requires an object with "
2501 : : "__aiter__ method, got %.100s",
2502 : : type->tp_name);
2503 [ - + ]: 1 : Py_DECREF(obj);
2504 : 1 : goto error;
2505 : : }
2506 : :
2507 [ + - ]: 155 : if (Py_TYPE(iter)->tp_as_async == NULL ||
2508 [ + + ]: 155 : Py_TYPE(iter)->tp_as_async->am_anext == NULL) {
2509 : :
2510 : 1 : SET_TOP(NULL);
2511 : 1 : _PyErr_Format(tstate, PyExc_TypeError,
2512 : : "'async for' received an object from __aiter__ "
2513 : : "that does not implement __anext__: %.100s",
2514 : 1 : Py_TYPE(iter)->tp_name);
2515 [ - + ]: 1 : Py_DECREF(iter);
2516 : 1 : goto error;
2517 : : }
2518 : :
2519 : 154 : SET_TOP(iter);
2520 : 154 : DISPATCH();
2521 : : }
2522 : :
2523 : 763 : TARGET(GET_ANEXT) {
2524 : 763 : unaryfunc getter = NULL;
2525 : 763 : PyObject *next_iter = NULL;
2526 : 763 : PyObject *awaitable = NULL;
2527 : 763 : PyObject *aiter = TOP();
2528 : 763 : PyTypeObject *type = Py_TYPE(aiter);
2529 : :
2530 [ + + ]: 763 : if (PyAsyncGen_CheckExact(aiter)) {
2531 : 434 : awaitable = type->tp_as_async->am_anext(aiter);
2532 [ - + ]: 434 : if (awaitable == NULL) {
2533 : 0 : goto error;
2534 : : }
2535 : : } else {
2536 [ + - ]: 329 : if (type->tp_as_async != NULL){
2537 : 329 : getter = type->tp_as_async->am_anext;
2538 : : }
2539 : :
2540 [ + - ]: 329 : if (getter != NULL) {
2541 : 329 : next_iter = (*getter)(aiter);
2542 [ - + ]: 329 : if (next_iter == NULL) {
2543 : 0 : goto error;
2544 : : }
2545 : : }
2546 : : else {
2547 : 0 : _PyErr_Format(tstate, PyExc_TypeError,
2548 : : "'async for' requires an iterator with "
2549 : : "__anext__ method, got %.100s",
2550 : : type->tp_name);
2551 : 0 : goto error;
2552 : : }
2553 : :
2554 : 329 : awaitable = _PyCoro_GetAwaitableIter(next_iter);
2555 [ + + ]: 329 : if (awaitable == NULL) {
2556 : 2 : _PyErr_FormatFromCause(
2557 : : PyExc_TypeError,
2558 : : "'async for' received an invalid object "
2559 : : "from __anext__: %.100s",
2560 : 2 : Py_TYPE(next_iter)->tp_name);
2561 : :
2562 [ - + ]: 2 : Py_DECREF(next_iter);
2563 : 2 : goto error;
2564 : : } else {
2565 [ - + ]: 327 : Py_DECREF(next_iter);
2566 : : }
2567 : : }
2568 : :
2569 : 761 : PUSH(awaitable);
2570 : : PREDICT(LOAD_CONST);
2571 : 761 : DISPATCH();
2572 : : }
2573 : :
2574 : 31561 : TARGET(GET_AWAITABLE) {
2575 : 31561 : PREDICTED(GET_AWAITABLE);
2576 : 31561 : PyObject *iterable = TOP();
2577 : 31561 : PyObject *iter = _PyCoro_GetAwaitableIter(iterable);
2578 : :
2579 [ + + ]: 31561 : if (iter == NULL) {
2580 : 28 : format_awaitable_error(tstate, Py_TYPE(iterable), oparg);
2581 : : }
2582 : :
2583 [ + + ]: 31561 : Py_DECREF(iterable);
2584 : :
2585 [ + + + + ]: 31561 : if (iter != NULL && PyCoro_CheckExact(iter)) {
2586 : 17560 : PyObject *yf = _PyGen_yf((PyGenObject*)iter);
2587 [ + + ]: 17560 : if (yf != NULL) {
2588 : : /* `iter` is a coroutine object that is being
2589 : : awaited, `yf` is a pointer to the current awaitable
2590 : : being awaited on. */
2591 [ - + ]: 2 : Py_DECREF(yf);
2592 [ + - - + ]: 2 : Py_CLEAR(iter);
2593 : 2 : _PyErr_SetString(tstate, PyExc_RuntimeError,
2594 : : "coroutine is being awaited already");
2595 : : /* The code below jumps to `error` if `iter` is NULL. */
2596 : : }
2597 : : }
2598 : :
2599 : 31561 : SET_TOP(iter); /* Even if it's NULL */
2600 : :
2601 [ + + ]: 31561 : if (iter == NULL) {
2602 : 30 : goto error;
2603 : : }
2604 : :
2605 : : PREDICT(LOAD_CONST);
2606 : 31531 : DISPATCH();
2607 : : }
2608 : :
2609 : 6756999 : TARGET(SEND) {
2610 : : assert(frame->is_entry);
2611 : : assert(STACK_LEVEL() >= 2);
2612 : 6756999 : PyObject *v = POP();
2613 : 6756999 : PyObject *receiver = TOP();
2614 : : PySendResult gen_status;
2615 : : PyObject *retval;
2616 [ + + ]: 6756999 : if (tstate->c_tracefunc == NULL) {
2617 : 6756001 : gen_status = PyIter_Send(receiver, v, &retval);
2618 : : } else {
2619 [ + - + + ]: 998 : if (Py_IsNone(v) && PyIter_Check(receiver)) {
2620 : 938 : retval = Py_TYPE(receiver)->tp_iternext(receiver);
2621 : : }
2622 : : else {
2623 : 60 : retval = PyObject_CallMethodOneArg(receiver, &_Py_ID(send), v);
2624 : : }
2625 [ + + ]: 998 : if (retval == NULL) {
2626 [ + - ]: 198 : if (tstate->c_tracefunc != NULL
2627 [ + + ]: 198 : && _PyErr_ExceptionMatches(tstate, PyExc_StopIteration))
2628 : 81 : call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, frame);
2629 [ + + ]: 198 : if (_PyGen_FetchStopIterationValue(&retval) == 0) {
2630 : 187 : gen_status = PYGEN_RETURN;
2631 : : }
2632 : : else {
2633 : 11 : gen_status = PYGEN_ERROR;
2634 : : }
2635 : : }
2636 : : else {
2637 : 800 : gen_status = PYGEN_NEXT;
2638 : : }
2639 : : }
2640 [ - + ]: 6756999 : Py_DECREF(v);
2641 [ + + ]: 6756999 : if (gen_status == PYGEN_ERROR) {
2642 : : assert(retval == NULL);
2643 : 740 : goto error;
2644 : : }
2645 [ + + ]: 6756259 : if (gen_status == PYGEN_RETURN) {
2646 : : assert(retval != NULL);
2647 [ + + ]: 786965 : Py_DECREF(receiver);
2648 : 786965 : SET_TOP(retval);
2649 : 786965 : JUMPBY(oparg);
2650 : 786965 : DISPATCH();
2651 : : }
2652 : : assert(gen_status == PYGEN_NEXT);
2653 : : assert(retval != NULL);
2654 : 5969294 : PUSH(retval);
2655 : 5969294 : DISPATCH();
2656 : : }
2657 : :
2658 : 434 : TARGET(ASYNC_GEN_WRAP) {
2659 : 434 : PyObject *v = TOP();
2660 : : assert(frame->f_code->co_flags & CO_ASYNC_GENERATOR);
2661 : 434 : PyObject *w = _PyAsyncGenValueWrapperNew(v);
2662 [ - + ]: 434 : if (w == NULL) {
2663 : 0 : goto error;
2664 : : }
2665 : 434 : SET_TOP(w);
2666 [ - + ]: 434 : Py_DECREF(v);
2667 : 434 : DISPATCH();
2668 : : }
2669 : :
2670 : 45070462 : TARGET(YIELD_VALUE) {
2671 : : assert(oparg == STACK_LEVEL());
2672 : : assert(frame->is_entry);
2673 : 45070462 : PyObject *retval = POP();
2674 : 45070462 : _PyFrame_GetGenerator(frame)->gi_frame_state = FRAME_SUSPENDED;
2675 : 45070462 : _PyFrame_SetStackPointer(frame, stack_pointer);
2676 [ + + - + : 45070462 : TRACE_FUNCTION_EXIT();
- - ]
2677 [ - + ]: 45070462 : DTRACE_FUNCTION_EXIT();
2678 : 45070462 : _Py_LeaveRecursiveCallTstate(tstate);
2679 : : /* Restore previous cframe and return. */
2680 : 45070462 : tstate->cframe = cframe.previous;
2681 : 45070462 : tstate->cframe->use_tracing = cframe.use_tracing;
2682 : : assert(tstate->cframe->current_frame == frame->previous);
2683 : : assert(!_PyErr_Occurred(tstate));
2684 : 45070462 : return retval;
2685 : : }
2686 : :
2687 : 3900595 : TARGET(POP_EXCEPT) {
2688 : 3900595 : _PyErr_StackItem *exc_info = tstate->exc_info;
2689 : 3900595 : PyObject *value = exc_info->exc_value;
2690 : 3900595 : exc_info->exc_value = POP();
2691 [ + - + + ]: 3900595 : Py_XDECREF(value);
2692 : 3900595 : DISPATCH();
2693 : : }
2694 : :
2695 : 668876 : TARGET(RERAISE) {
2696 [ + + ]: 668876 : if (oparg) {
2697 : 421332 : PyObject *lasti = PEEK(oparg + 1);
2698 [ + - ]: 421332 : if (PyLong_Check(lasti)) {
2699 : 421332 : frame->prev_instr = first_instr + PyLong_AsLong(lasti);
2700 : : assert(!_PyErr_Occurred(tstate));
2701 : : }
2702 : : else {
2703 : : assert(PyLong_Check(lasti));
2704 : 0 : _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int");
2705 : 0 : goto error;
2706 : : }
2707 : : }
2708 : 668876 : PyObject *val = POP();
2709 : : assert(val && PyExceptionInstance_Check(val));
2710 : 668876 : PyObject *exc = Py_NewRef(PyExceptionInstance_Class(val));
2711 : 668876 : PyObject *tb = PyException_GetTraceback(val);
2712 : 668876 : _PyErr_Restore(tstate, exc, val, tb);
2713 : 668876 : goto exception_unwind;
2714 : : }
2715 : :
2716 : 150 : TARGET(PREP_RERAISE_STAR) {
2717 : 150 : PyObject *excs = POP();
2718 : : assert(PyList_Check(excs));
2719 : 150 : PyObject *orig = POP();
2720 : :
2721 : 150 : PyObject *val = _PyExc_PrepReraiseStar(orig, excs);
2722 [ + - ]: 150 : Py_DECREF(excs);
2723 [ + + ]: 150 : Py_DECREF(orig);
2724 : :
2725 [ - + ]: 150 : if (val == NULL) {
2726 : 0 : goto error;
2727 : : }
2728 : :
2729 : 150 : PUSH(val);
2730 : 150 : DISPATCH();
2731 : : }
2732 : :
2733 : 140 : TARGET(END_ASYNC_FOR) {
2734 : 140 : PyObject *val = POP();
2735 : : assert(val && PyExceptionInstance_Check(val));
2736 [ + + ]: 140 : if (PyErr_GivenExceptionMatches(val, PyExc_StopAsyncIteration)) {
2737 [ + - ]: 130 : Py_DECREF(val);
2738 [ + + ]: 130 : Py_DECREF(POP());
2739 : 130 : DISPATCH();
2740 : : }
2741 : : else {
2742 : 10 : PyObject *exc = Py_NewRef(PyExceptionInstance_Class(val));
2743 : 10 : PyObject *tb = PyException_GetTraceback(val);
2744 : 10 : _PyErr_Restore(tstate, exc, val, tb);
2745 : 10 : goto exception_unwind;
2746 : : }
2747 : : }
2748 : :
2749 : 27 : TARGET(LOAD_ASSERTION_ERROR) {
2750 : 27 : PyObject *value = PyExc_AssertionError;
2751 : 27 : Py_INCREF(value);
2752 : 27 : PUSH(value);
2753 : 27 : DISPATCH();
2754 : : }
2755 : :
2756 : 937573 : TARGET(LOAD_BUILD_CLASS) {
2757 : : PyObject *bc;
2758 [ + - ]: 937573 : if (PyDict_CheckExact(BUILTINS())) {
2759 : 937573 : bc = _PyDict_GetItemWithError(BUILTINS(),
2760 : : &_Py_ID(__build_class__));
2761 [ + + ]: 937573 : if (bc == NULL) {
2762 [ + - ]: 1 : if (!_PyErr_Occurred(tstate)) {
2763 : 1 : _PyErr_SetString(tstate, PyExc_NameError,
2764 : : "__build_class__ not found");
2765 : : }
2766 : 1 : goto error;
2767 : : }
2768 : 937572 : Py_INCREF(bc);
2769 : : }
2770 : : else {
2771 : 0 : bc = PyObject_GetItem(BUILTINS(), &_Py_ID(__build_class__));
2772 [ # # ]: 0 : if (bc == NULL) {
2773 [ # # ]: 0 : if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
2774 : 0 : _PyErr_SetString(tstate, PyExc_NameError,
2775 : : "__build_class__ not found");
2776 : 0 : goto error;
2777 : : }
2778 : : }
2779 : 937572 : PUSH(bc);
2780 : 937572 : DISPATCH();
2781 : : }
2782 : :
2783 : 16660688 : TARGET(STORE_NAME) {
2784 : 16660688 : PyObject *name = GETITEM(names, oparg);
2785 : 16660688 : PyObject *v = POP();
2786 : 16660688 : PyObject *ns = LOCALS();
2787 : : int err;
2788 [ - + ]: 16660688 : if (ns == NULL) {
2789 : 0 : _PyErr_Format(tstate, PyExc_SystemError,
2790 : : "no locals found when storing %R", name);
2791 [ # # ]: 0 : Py_DECREF(v);
2792 : 0 : goto error;
2793 : : }
2794 [ + + ]: 16660688 : if (PyDict_CheckExact(ns))
2795 : 16500639 : err = PyDict_SetItem(ns, name, v);
2796 : : else
2797 : 160049 : err = PyObject_SetItem(ns, name, v);
2798 [ + + ]: 16660688 : Py_DECREF(v);
2799 [ + + ]: 16660688 : if (err != 0)
2800 : 55 : goto error;
2801 : 16660633 : DISPATCH();
2802 : : }
2803 : :
2804 : 132969 : TARGET(DELETE_NAME) {
2805 : 132969 : PyObject *name = GETITEM(names, oparg);
2806 : 132969 : PyObject *ns = LOCALS();
2807 : : int err;
2808 [ - + ]: 132969 : if (ns == NULL) {
2809 : 0 : _PyErr_Format(tstate, PyExc_SystemError,
2810 : : "no locals when deleting %R", name);
2811 : 0 : goto error;
2812 : : }
2813 : 132969 : err = PyObject_DelItem(ns, name);
2814 [ - + ]: 132969 : if (err != 0) {
2815 : 0 : format_exc_check_arg(tstate, PyExc_NameError,
2816 : : NAME_ERROR_MSG,
2817 : : name);
2818 : 0 : goto error;
2819 : : }
2820 : 132969 : DISPATCH();
2821 : : }
2822 : :
2823 : 1049109 : TARGET(UNPACK_SEQUENCE) {
2824 : 3708858 : PREDICTED(UNPACK_SEQUENCE);
2825 : 3708858 : PyObject *seq = POP();
2826 : 3708858 : PyObject **top = stack_pointer + oparg;
2827 [ + + ]: 3708858 : if (!unpack_iterable(tstate, seq, oparg, -1, top)) {
2828 [ + + ]: 1426 : Py_DECREF(seq);
2829 : 1426 : goto error;
2830 : : }
2831 : 3707432 : STACK_GROW(oparg);
2832 [ + + ]: 3707432 : Py_DECREF(seq);
2833 : 3707432 : JUMPBY(INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE);
2834 : 3707432 : DISPATCH();
2835 : : }
2836 : :
2837 : 2773640 : TARGET(UNPACK_SEQUENCE_ADAPTIVE) {
2838 : : assert(cframe.use_tracing == 0);
2839 : 2773640 : _PyUnpackSequenceCache *cache = (_PyUnpackSequenceCache *)next_instr;
2840 [ + + ]: 2773640 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
2841 : 113891 : PyObject *seq = TOP();
2842 : 113891 : next_instr--;
2843 : 113891 : _Py_Specialize_UnpackSequence(seq, next_instr, oparg);
2844 : 113891 : NOTRACE_DISPATCH_SAME_OPARG();
2845 : : }
2846 : : else {
2847 : : STAT_INC(UNPACK_SEQUENCE, deferred);
2848 : 2659749 : DECREMENT_ADAPTIVE_COUNTER(cache);
2849 : 2659749 : JUMP_TO_INSTRUCTION(UNPACK_SEQUENCE);
2850 : : }
2851 : : }
2852 : :
2853 : 63454379 : TARGET(UNPACK_SEQUENCE_TWO_TUPLE) {
2854 : 63454379 : PyObject *seq = TOP();
2855 [ + + ]: 63454379 : DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
2856 [ + + ]: 63453589 : DEOPT_IF(PyTuple_GET_SIZE(seq) != 2, UNPACK_SEQUENCE);
2857 : : STAT_INC(UNPACK_SEQUENCE, hit);
2858 : 63453552 : SET_TOP(Py_NewRef(PyTuple_GET_ITEM(seq, 1)));
2859 : 63453552 : PUSH(Py_NewRef(PyTuple_GET_ITEM(seq, 0)));
2860 [ + + ]: 63453552 : Py_DECREF(seq);
2861 : 63453552 : JUMPBY(INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE);
2862 : 63453552 : NOTRACE_DISPATCH();
2863 : : }
2864 : :
2865 : 15551586 : TARGET(UNPACK_SEQUENCE_TUPLE) {
2866 : 15551586 : PyObject *seq = TOP();
2867 [ + + ]: 15551586 : DEOPT_IF(!PyTuple_CheckExact(seq), UNPACK_SEQUENCE);
2868 [ - + ]: 15551546 : DEOPT_IF(PyTuple_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
2869 : : STAT_INC(UNPACK_SEQUENCE, hit);
2870 : 15551546 : STACK_SHRINK(1);
2871 : 15551546 : PyObject **items = _PyTuple_ITEMS(seq);
2872 [ + + ]: 65432397 : while (oparg--) {
2873 : 49880851 : PUSH(Py_NewRef(items[oparg]));
2874 : : }
2875 [ + + ]: 15551546 : Py_DECREF(seq);
2876 : 15551546 : JUMPBY(INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE);
2877 : 15551546 : NOTRACE_DISPATCH();
2878 : : }
2879 : :
2880 : 602135 : TARGET(UNPACK_SEQUENCE_LIST) {
2881 : 602135 : PyObject *seq = TOP();
2882 [ + + ]: 602135 : DEOPT_IF(!PyList_CheckExact(seq), UNPACK_SEQUENCE);
2883 [ + + ]: 601796 : DEOPT_IF(PyList_GET_SIZE(seq) != oparg, UNPACK_SEQUENCE);
2884 : : STAT_INC(UNPACK_SEQUENCE, hit);
2885 : 601059 : STACK_SHRINK(1);
2886 : 601059 : PyObject **items = _PyList_ITEMS(seq);
2887 [ + + ]: 1934304 : while (oparg--) {
2888 : 1333245 : PUSH(Py_NewRef(items[oparg]));
2889 : : }
2890 [ + + ]: 601059 : Py_DECREF(seq);
2891 : 601059 : JUMPBY(INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE);
2892 : 601059 : NOTRACE_DISPATCH();
2893 : : }
2894 : :
2895 : 103662 : TARGET(UNPACK_EX) {
2896 : 103662 : int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
2897 : 103662 : PyObject *seq = POP();
2898 : 103662 : PyObject **top = stack_pointer + totalargs;
2899 [ + + ]: 103662 : if (!unpack_iterable(tstate, seq, oparg & 0xFF, oparg >> 8, top)) {
2900 [ + + ]: 4 : Py_DECREF(seq);
2901 : 4 : goto error;
2902 : : }
2903 : 103658 : STACK_GROW(totalargs);
2904 [ + + ]: 103658 : Py_DECREF(seq);
2905 : 103658 : DISPATCH();
2906 : : }
2907 : :
2908 : 7385603 : TARGET(STORE_ATTR) {
2909 : 26155290 : PREDICTED(STORE_ATTR);
2910 : 26155290 : PyObject *name = GETITEM(names, oparg);
2911 : 26155290 : PyObject *owner = TOP();
2912 : 26155290 : PyObject *v = SECOND();
2913 : : int err;
2914 : 26155290 : STACK_SHRINK(2);
2915 : 26155290 : err = PyObject_SetAttr(owner, name, v);
2916 [ + + ]: 26155290 : Py_DECREF(v);
2917 [ + + ]: 26155290 : Py_DECREF(owner);
2918 [ + + ]: 26155290 : if (err != 0) {
2919 : 1093 : goto error;
2920 : : }
2921 : 26154197 : JUMPBY(INLINE_CACHE_ENTRIES_STORE_ATTR);
2922 : 26154197 : DISPATCH();
2923 : : }
2924 : :
2925 : 3378748 : TARGET(DELETE_ATTR) {
2926 : 3378748 : PyObject *name = GETITEM(names, oparg);
2927 : 3378748 : PyObject *owner = POP();
2928 : : int err;
2929 : 3378748 : err = PyObject_SetAttr(owner, name, (PyObject *)NULL);
2930 [ + + ]: 3378748 : Py_DECREF(owner);
2931 [ + + ]: 3378748 : if (err != 0)
2932 : 242 : goto error;
2933 : 3378506 : DISPATCH();
2934 : : }
2935 : :
2936 : 126777 : TARGET(STORE_GLOBAL) {
2937 : 126777 : PyObject *name = GETITEM(names, oparg);
2938 : 126777 : PyObject *v = POP();
2939 : : int err;
2940 : 126777 : err = PyDict_SetItem(GLOBALS(), name, v);
2941 [ - + ]: 126777 : Py_DECREF(v);
2942 [ - + ]: 126777 : if (err != 0)
2943 : 0 : goto error;
2944 : 126777 : DISPATCH();
2945 : : }
2946 : :
2947 : 11 : TARGET(DELETE_GLOBAL) {
2948 : 11 : PyObject *name = GETITEM(names, oparg);
2949 : : int err;
2950 : 11 : err = PyDict_DelItem(GLOBALS(), name);
2951 [ - + ]: 11 : if (err != 0) {
2952 [ # # ]: 0 : if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
2953 : 0 : format_exc_check_arg(tstate, PyExc_NameError,
2954 : : NAME_ERROR_MSG, name);
2955 : : }
2956 : 0 : goto error;
2957 : : }
2958 : 11 : DISPATCH();
2959 : : }
2960 : :
2961 : 11070387 : TARGET(LOAD_NAME) {
2962 : 11070387 : PyObject *name = GETITEM(names, oparg);
2963 : 11070387 : PyObject *locals = LOCALS();
2964 : : PyObject *v;
2965 [ - + ]: 11070387 : if (locals == NULL) {
2966 : 0 : _PyErr_Format(tstate, PyExc_SystemError,
2967 : : "no locals when loading %R", name);
2968 : 0 : goto error;
2969 : : }
2970 [ + + ]: 11070387 : if (PyDict_CheckExact(locals)) {
2971 : 11009853 : v = PyDict_GetItemWithError(locals, name);
2972 [ + + ]: 11009853 : if (v != NULL) {
2973 : 7705031 : Py_INCREF(v);
2974 : : }
2975 [ - + ]: 3304822 : else if (_PyErr_Occurred(tstate)) {
2976 : 0 : goto error;
2977 : : }
2978 : : }
2979 : : else {
2980 : 60534 : v = PyObject_GetItem(locals, name);
2981 [ + + ]: 60534 : if (v == NULL) {
2982 [ + + ]: 47826 : if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError))
2983 : 1 : goto error;
2984 : 47825 : _PyErr_Clear(tstate);
2985 : : }
2986 : : }
2987 [ + + ]: 11070386 : if (v == NULL) {
2988 : 3352647 : v = PyDict_GetItemWithError(GLOBALS(), name);
2989 [ + + ]: 3352647 : if (v != NULL) {
2990 : 1648805 : Py_INCREF(v);
2991 : : }
2992 [ - + ]: 1703842 : else if (_PyErr_Occurred(tstate)) {
2993 : 0 : goto error;
2994 : : }
2995 : : else {
2996 [ + + ]: 1703842 : if (PyDict_CheckExact(BUILTINS())) {
2997 : 1703841 : v = PyDict_GetItemWithError(BUILTINS(), name);
2998 [ + + ]: 1703841 : if (v == NULL) {
2999 [ + - ]: 854 : if (!_PyErr_Occurred(tstate)) {
3000 : 854 : format_exc_check_arg(
3001 : : tstate, PyExc_NameError,
3002 : : NAME_ERROR_MSG, name);
3003 : : }
3004 : 854 : goto error;
3005 : : }
3006 : 1702987 : Py_INCREF(v);
3007 : : }
3008 : : else {
3009 : 1 : v = PyObject_GetItem(BUILTINS(), name);
3010 [ + - ]: 1 : if (v == NULL) {
3011 [ - + ]: 1 : if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
3012 : 0 : format_exc_check_arg(
3013 : : tstate, PyExc_NameError,
3014 : : NAME_ERROR_MSG, name);
3015 : : }
3016 : 1 : goto error;
3017 : : }
3018 : : }
3019 : : }
3020 : : }
3021 : 11069531 : PUSH(v);
3022 : 11069531 : DISPATCH();
3023 : : }
3024 : :
3025 : 29990952 : TARGET(LOAD_GLOBAL) {
3026 : 33704702 : PREDICTED(LOAD_GLOBAL);
3027 : 33704702 : int push_null = oparg & 1;
3028 : 33704702 : PEEK(0) = NULL;
3029 : 33704702 : PyObject *name = GETITEM(names, oparg>>1);
3030 : : PyObject *v;
3031 [ + + ]: 33704702 : if (PyDict_CheckExact(GLOBALS())
3032 [ + - ]: 33674473 : && PyDict_CheckExact(BUILTINS()))
3033 : : {
3034 : 33674473 : v = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(),
3035 : 33674473 : (PyDictObject *)BUILTINS(),
3036 : : name);
3037 [ + + ]: 33674473 : if (v == NULL) {
3038 [ + - ]: 99 : if (!_PyErr_Occurred(tstate)) {
3039 : : /* _PyDict_LoadGlobal() returns NULL without raising
3040 : : * an exception if the key doesn't exist */
3041 : 99 : format_exc_check_arg(tstate, PyExc_NameError,
3042 : : NAME_ERROR_MSG, name);
3043 : : }
3044 : 99 : goto error;
3045 : : }
3046 : 33674374 : Py_INCREF(v);
3047 : : }
3048 : : else {
3049 : : /* Slow-path if globals or builtins is not a dict */
3050 : :
3051 : : /* namespace 1: globals */
3052 : 30229 : v = PyObject_GetItem(GLOBALS(), name);
3053 [ + + ]: 30229 : if (v == NULL) {
3054 [ - + ]: 78 : if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
3055 : 0 : goto error;
3056 : : }
3057 : 78 : _PyErr_Clear(tstate);
3058 : :
3059 : : /* namespace 2: builtins */
3060 : 78 : v = PyObject_GetItem(BUILTINS(), name);
3061 [ - + ]: 78 : if (v == NULL) {
3062 [ # # ]: 0 : if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
3063 : 0 : format_exc_check_arg(
3064 : : tstate, PyExc_NameError,
3065 : : NAME_ERROR_MSG, name);
3066 : : }
3067 : 0 : goto error;
3068 : : }
3069 : : }
3070 : : }
3071 : : /* Skip over inline cache */
3072 : 33704603 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_GLOBAL);
3073 : 33704603 : STACK_GROW(push_null);
3074 : 33704603 : PUSH(v);
3075 : 33704603 : DISPATCH();
3076 : : }
3077 : :
3078 : 5624232 : TARGET(LOAD_GLOBAL_ADAPTIVE) {
3079 : : assert(cframe.use_tracing == 0);
3080 : 5624232 : _PyLoadGlobalCache *cache = (_PyLoadGlobalCache *)next_instr;
3081 [ + + ]: 5624232 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
3082 : 1910482 : PyObject *name = GETITEM(names, oparg>>1);
3083 : 1910482 : next_instr--;
3084 [ - + ]: 1910482 : if (_Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name) < 0) {
3085 : 0 : goto error;
3086 : : }
3087 : 1910482 : NOTRACE_DISPATCH_SAME_OPARG();
3088 : : }
3089 : : else {
3090 : : STAT_INC(LOAD_GLOBAL, deferred);
3091 : 3713750 : DECREMENT_ADAPTIVE_COUNTER(cache);
3092 : 3713750 : JUMP_TO_INSTRUCTION(LOAD_GLOBAL);
3093 : : }
3094 : : }
3095 : :
3096 : 294209737 : TARGET(LOAD_GLOBAL_MODULE) {
3097 : : assert(cframe.use_tracing == 0);
3098 [ - + ]: 294209737 : DEOPT_IF(!PyDict_CheckExact(GLOBALS()), LOAD_GLOBAL);
3099 : 294209737 : PyDictObject *dict = (PyDictObject *)GLOBALS();
3100 : 294209737 : _PyLoadGlobalCache *cache = (_PyLoadGlobalCache *)next_instr;
3101 : 294209737 : uint32_t version = read_u32(cache->module_keys_version);
3102 [ + + ]: 294209737 : DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL);
3103 : : assert(DK_IS_UNICODE(dict->ma_keys));
3104 : 287602321 : PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(dict->ma_keys);
3105 : 287602321 : PyObject *res = entries[cache->index].me_value;
3106 [ - + ]: 287602321 : DEOPT_IF(res == NULL, LOAD_GLOBAL);
3107 : 287602321 : int push_null = oparg & 1;
3108 : 287602321 : PEEK(0) = NULL;
3109 : 287602321 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_GLOBAL);
3110 : : STAT_INC(LOAD_GLOBAL, hit);
3111 : 287602321 : STACK_GROW(push_null+1);
3112 : 287602321 : Py_INCREF(res);
3113 : 287602321 : SET_TOP(res);
3114 : 287602321 : NOTRACE_DISPATCH();
3115 : : }
3116 : :
3117 : 217516493 : TARGET(LOAD_GLOBAL_BUILTIN) {
3118 : : assert(cframe.use_tracing == 0);
3119 [ - + ]: 217516493 : DEOPT_IF(!PyDict_CheckExact(GLOBALS()), LOAD_GLOBAL);
3120 [ - + ]: 217516493 : DEOPT_IF(!PyDict_CheckExact(BUILTINS()), LOAD_GLOBAL);
3121 : 217516493 : PyDictObject *mdict = (PyDictObject *)GLOBALS();
3122 : 217516493 : PyDictObject *bdict = (PyDictObject *)BUILTINS();
3123 : 217516493 : _PyLoadGlobalCache *cache = (_PyLoadGlobalCache *)next_instr;
3124 : 217516493 : uint32_t mod_version = read_u32(cache->module_keys_version);
3125 : 217516493 : uint16_t bltn_version = cache->builtin_keys_version;
3126 [ + + ]: 217516493 : DEOPT_IF(mdict->ma_keys->dk_version != mod_version, LOAD_GLOBAL);
3127 [ + + ]: 213329703 : DEOPT_IF(bdict->ma_keys->dk_version != bltn_version, LOAD_GLOBAL);
3128 : : assert(DK_IS_UNICODE(bdict->ma_keys));
3129 : 211992995 : PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(bdict->ma_keys);
3130 : 211992995 : PyObject *res = entries[cache->index].me_value;
3131 [ - + ]: 211992995 : DEOPT_IF(res == NULL, LOAD_GLOBAL);
3132 : 211992995 : int push_null = oparg & 1;
3133 : 211992995 : PEEK(0) = NULL;
3134 : 211992995 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_GLOBAL);
3135 : : STAT_INC(LOAD_GLOBAL, hit);
3136 : 211992995 : STACK_GROW(push_null+1);
3137 : 211992995 : Py_INCREF(res);
3138 : 211992995 : SET_TOP(res);
3139 : 211992995 : NOTRACE_DISPATCH();
3140 : : }
3141 : :
3142 : 809915 : TARGET(DELETE_FAST) {
3143 : 809915 : PyObject *v = GETLOCAL(oparg);
3144 [ + - ]: 809915 : if (v != NULL) {
3145 [ + - + + ]: 809915 : SETLOCAL(oparg, NULL);
3146 : 809915 : DISPATCH();
3147 : : }
3148 : 0 : goto unbound_local_error;
3149 : : }
3150 : :
3151 : 4526562 : TARGET(MAKE_CELL) {
3152 : : // "initial" is probably NULL but not if it's an arg (or set
3153 : : // via PyFrame_LocalsToFast() before MAKE_CELL has run).
3154 : 4526562 : PyObject *initial = GETLOCAL(oparg);
3155 : 4526562 : PyObject *cell = PyCell_New(initial);
3156 [ - + ]: 4526562 : if (cell == NULL) {
3157 : 0 : goto resume_with_error;
3158 : : }
3159 [ + + - + ]: 4526562 : SETLOCAL(oparg, cell);
3160 : 4526562 : DISPATCH();
3161 : : }
3162 : :
3163 : 38 : TARGET(DELETE_DEREF) {
3164 : 38 : PyObject *cell = GETLOCAL(oparg);
3165 : 38 : PyObject *oldobj = PyCell_GET(cell);
3166 [ + - ]: 38 : if (oldobj != NULL) {
3167 : 38 : PyCell_SET(cell, NULL);
3168 [ + + ]: 38 : Py_DECREF(oldobj);
3169 : 38 : DISPATCH();
3170 : : }
3171 : 0 : format_exc_unbound(tstate, frame->f_code, oparg);
3172 : 0 : goto error;
3173 : : }
3174 : :
3175 : 6066 : TARGET(LOAD_CLASSDEREF) {
3176 : 6066 : PyObject *name, *value, *locals = LOCALS();
3177 : : assert(locals);
3178 : : assert(oparg >= 0 && oparg < frame->f_code->co_nlocalsplus);
3179 : 6066 : name = PyTuple_GET_ITEM(frame->f_code->co_localsplusnames, oparg);
3180 [ + + ]: 6066 : if (PyDict_CheckExact(locals)) {
3181 : 5629 : value = PyDict_GetItemWithError(locals, name);
3182 [ + + ]: 5629 : if (value != NULL) {
3183 : 1 : Py_INCREF(value);
3184 : : }
3185 [ - + ]: 5628 : else if (_PyErr_Occurred(tstate)) {
3186 : 0 : goto error;
3187 : : }
3188 : : }
3189 : : else {
3190 : 437 : value = PyObject_GetItem(locals, name);
3191 [ + - ]: 437 : if (value == NULL) {
3192 [ - + ]: 437 : if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
3193 : 0 : goto error;
3194 : : }
3195 : 437 : _PyErr_Clear(tstate);
3196 : : }
3197 : : }
3198 [ + + ]: 6066 : if (!value) {
3199 : 6065 : PyObject *cell = GETLOCAL(oparg);
3200 : 6065 : value = PyCell_GET(cell);
3201 [ - + ]: 6065 : if (value == NULL) {
3202 : 0 : format_exc_unbound(tstate, frame->f_code, oparg);
3203 : 0 : goto error;
3204 : : }
3205 : 6065 : Py_INCREF(value);
3206 : : }
3207 : 6066 : PUSH(value);
3208 : 6066 : DISPATCH();
3209 : : }
3210 : :
3211 : 94356944 : TARGET(LOAD_DEREF) {
3212 : 94356944 : PyObject *cell = GETLOCAL(oparg);
3213 : 94356944 : PyObject *value = PyCell_GET(cell);
3214 [ + + ]: 94356944 : if (value == NULL) {
3215 : 8 : format_exc_unbound(tstate, frame->f_code, oparg);
3216 : 8 : goto error;
3217 : : }
3218 : 94356936 : Py_INCREF(value);
3219 : 94356936 : PUSH(value);
3220 : 94356936 : DISPATCH();
3221 : : }
3222 : :
3223 : 2339199 : TARGET(STORE_DEREF) {
3224 : 2339199 : PyObject *v = POP();
3225 : 2339199 : PyObject *cell = GETLOCAL(oparg);
3226 : 2339199 : PyObject *oldobj = PyCell_GET(cell);
3227 : 2339199 : PyCell_SET(cell, v);
3228 [ + + + + ]: 2339199 : Py_XDECREF(oldobj);
3229 : 2339199 : DISPATCH();
3230 : : }
3231 : :
3232 : 34962312 : TARGET(COPY_FREE_VARS) {
3233 : : /* Copy closure variables to free variables */
3234 : 34962312 : PyCodeObject *co = frame->f_code;
3235 : 34962312 : PyObject *closure = frame->f_func->func_closure;
3236 : 34962312 : int offset = co->co_nlocals + co->co_nplaincellvars;
3237 : : assert(oparg == co->co_nfreevars);
3238 [ + + ]: 92851963 : for (int i = 0; i < oparg; ++i) {
3239 : 57889651 : PyObject *o = PyTuple_GET_ITEM(closure, i);
3240 : 57889651 : Py_INCREF(o);
3241 : 57889651 : frame->localsplus[offset + i] = o;
3242 : : }
3243 : 34962312 : DISPATCH();
3244 : : }
3245 : :
3246 : 2276741 : TARGET(BUILD_STRING) {
3247 : : PyObject *str;
3248 : 2276741 : str = _PyUnicode_JoinArray(&_Py_STR(empty),
3249 : 2276741 : stack_pointer - oparg, oparg);
3250 [ - + ]: 2276741 : if (str == NULL)
3251 : 0 : goto error;
3252 [ + + ]: 8863792 : while (--oparg >= 0) {
3253 : 6587051 : PyObject *item = POP();
3254 [ + + ]: 6587051 : Py_DECREF(item);
3255 : : }
3256 : 2276741 : PUSH(str);
3257 : 2276741 : DISPATCH();
3258 : : }
3259 : :
3260 : 75914643 : TARGET(BUILD_TUPLE) {
3261 : 75914643 : PyObject *tup = PyTuple_New(oparg);
3262 [ - + ]: 75914643 : if (tup == NULL)
3263 : 0 : goto error;
3264 [ + + ]: 261209580 : while (--oparg >= 0) {
3265 : 185294937 : PyObject *item = POP();
3266 : 185294937 : PyTuple_SET_ITEM(tup, oparg, item);
3267 : : }
3268 : 75914643 : PUSH(tup);
3269 : 75914643 : DISPATCH();
3270 : : }
3271 : :
3272 : 16222000 : TARGET(BUILD_LIST) {
3273 : 16222000 : PyObject *list = PyList_New(oparg);
3274 [ - + ]: 16222000 : if (list == NULL)
3275 : 0 : goto error;
3276 [ + + ]: 58380299 : while (--oparg >= 0) {
3277 : 42158299 : PyObject *item = POP();
3278 : 42158299 : PyList_SET_ITEM(list, oparg, item);
3279 : : }
3280 : 16222000 : PUSH(list);
3281 : 16222000 : DISPATCH();
3282 : : }
3283 : :
3284 : 1085140 : TARGET(LIST_TO_TUPLE) {
3285 : 1085140 : PyObject *list = POP();
3286 : 1085140 : PyObject *tuple = PyList_AsTuple(list);
3287 [ + - ]: 1085140 : Py_DECREF(list);
3288 [ - + ]: 1085140 : if (tuple == NULL) {
3289 : 0 : goto error;
3290 : : }
3291 : 1085140 : PUSH(tuple);
3292 : 1085140 : DISPATCH();
3293 : : }
3294 : :
3295 : 1284086 : TARGET(LIST_EXTEND) {
3296 : 1284086 : PyObject *iterable = POP();
3297 : 1284086 : PyObject *list = PEEK(oparg);
3298 : 1284086 : PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
3299 [ + + ]: 1284086 : if (none_val == NULL) {
3300 [ + - ]: 20 : if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) &&
3301 [ + + + + ]: 20 : (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
3302 : : {
3303 : 16 : _PyErr_Clear(tstate);
3304 : 16 : _PyErr_Format(tstate, PyExc_TypeError,
3305 : : "Value after * must be an iterable, not %.200s",
3306 : 16 : Py_TYPE(iterable)->tp_name);
3307 : : }
3308 [ + + ]: 20 : Py_DECREF(iterable);
3309 : 20 : goto error;
3310 : : }
3311 [ - + ]: 1284066 : Py_DECREF(none_val);
3312 [ + + ]: 1284066 : Py_DECREF(iterable);
3313 : 1284066 : DISPATCH();
3314 : : }
3315 : :
3316 : 6604 : TARGET(SET_UPDATE) {
3317 : 6604 : PyObject *iterable = POP();
3318 : 6604 : PyObject *set = PEEK(oparg);
3319 : 6604 : int err = _PySet_Update(set, iterable);
3320 [ + + ]: 6604 : Py_DECREF(iterable);
3321 [ + + ]: 6604 : if (err < 0) {
3322 : 1 : goto error;
3323 : : }
3324 : 6603 : DISPATCH();
3325 : : }
3326 : :
3327 : 145409 : TARGET(BUILD_SET) {
3328 : 145409 : PyObject *set = PySet_New(NULL);
3329 : 145409 : int err = 0;
3330 : : int i;
3331 [ - + ]: 145409 : if (set == NULL)
3332 : 0 : goto error;
3333 [ + + ]: 524067 : for (i = oparg; i > 0; i--) {
3334 : 378658 : PyObject *item = PEEK(i);
3335 [ + - ]: 378658 : if (err == 0)
3336 : 378658 : err = PySet_Add(set, item);
3337 [ + + ]: 378658 : Py_DECREF(item);
3338 : : }
3339 : 145409 : STACK_SHRINK(oparg);
3340 [ + + ]: 145409 : if (err != 0) {
3341 [ + - ]: 1 : Py_DECREF(set);
3342 : 1 : goto error;
3343 : : }
3344 : 145408 : PUSH(set);
3345 : 145408 : DISPATCH();
3346 : : }
3347 : :
3348 : 16817942 : TARGET(BUILD_MAP) {
3349 : 16817942 : PyObject *map = _PyDict_FromItems(
3350 : 16817942 : &PEEK(2*oparg), 2,
3351 : 16817942 : &PEEK(2*oparg - 1), 2,
3352 : : oparg);
3353 [ - + ]: 16817942 : if (map == NULL)
3354 : 0 : goto error;
3355 : :
3356 [ + + ]: 17677808 : while (oparg--) {
3357 [ - + ]: 859866 : Py_DECREF(POP());
3358 [ - + ]: 859866 : Py_DECREF(POP());
3359 : : }
3360 : 16817942 : PUSH(map);
3361 : 16817942 : DISPATCH();
3362 : : }
3363 : :
3364 : 2307 : TARGET(SETUP_ANNOTATIONS) {
3365 : : int err;
3366 : : PyObject *ann_dict;
3367 [ - + ]: 2307 : if (LOCALS() == NULL) {
3368 : 0 : _PyErr_Format(tstate, PyExc_SystemError,
3369 : : "no locals found when setting up annotations");
3370 : 0 : goto error;
3371 : : }
3372 : : /* check if __annotations__ in locals()... */
3373 [ + + ]: 2307 : if (PyDict_CheckExact(LOCALS())) {
3374 : 2305 : ann_dict = _PyDict_GetItemWithError(LOCALS(),
3375 : : &_Py_ID(__annotations__));
3376 [ + + ]: 2305 : if (ann_dict == NULL) {
3377 [ - + ]: 2302 : if (_PyErr_Occurred(tstate)) {
3378 : 0 : goto error;
3379 : : }
3380 : : /* ...if not, create a new one */
3381 : 2302 : ann_dict = PyDict_New();
3382 [ - + ]: 2302 : if (ann_dict == NULL) {
3383 : 0 : goto error;
3384 : : }
3385 : 2302 : err = PyDict_SetItem(LOCALS(), &_Py_ID(__annotations__),
3386 : : ann_dict);
3387 [ - + ]: 2302 : Py_DECREF(ann_dict);
3388 [ - + ]: 2302 : if (err != 0) {
3389 : 0 : goto error;
3390 : : }
3391 : : }
3392 : : }
3393 : : else {
3394 : : /* do the same if locals() is not a dict */
3395 : 2 : ann_dict = PyObject_GetItem(LOCALS(), &_Py_ID(__annotations__));
3396 [ + + ]: 2 : if (ann_dict == NULL) {
3397 [ - + ]: 1 : if (!_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
3398 : 0 : goto error;
3399 : : }
3400 : 1 : _PyErr_Clear(tstate);
3401 : 1 : ann_dict = PyDict_New();
3402 [ - + ]: 1 : if (ann_dict == NULL) {
3403 : 0 : goto error;
3404 : : }
3405 : 1 : err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
3406 : : ann_dict);
3407 [ - + ]: 1 : Py_DECREF(ann_dict);
3408 [ - + ]: 1 : if (err != 0) {
3409 : 0 : goto error;
3410 : : }
3411 : : }
3412 : : else {
3413 [ - + ]: 1 : Py_DECREF(ann_dict);
3414 : : }
3415 : : }
3416 : 2307 : DISPATCH();
3417 : : }
3418 : :
3419 : 770152 : TARGET(BUILD_CONST_KEY_MAP) {
3420 : : PyObject *map;
3421 : 770152 : PyObject *keys = TOP();
3422 [ + - ]: 770152 : if (!PyTuple_CheckExact(keys) ||
3423 [ - + ]: 770152 : PyTuple_GET_SIZE(keys) != (Py_ssize_t)oparg) {
3424 : 0 : _PyErr_SetString(tstate, PyExc_SystemError,
3425 : : "bad BUILD_CONST_KEY_MAP keys argument");
3426 : 0 : goto error;
3427 : : }
3428 : 770152 : map = _PyDict_FromItems(
3429 : 770152 : &PyTuple_GET_ITEM(keys, 0), 1,
3430 : 770152 : &PEEK(oparg + 1), 1, oparg);
3431 [ + + ]: 770152 : if (map == NULL) {
3432 : 1 : goto error;
3433 : : }
3434 : :
3435 [ - + ]: 770151 : Py_DECREF(POP());
3436 [ + + ]: 3118337 : while (oparg--) {
3437 [ - + ]: 2348186 : Py_DECREF(POP());
3438 : : }
3439 : 770151 : PUSH(map);
3440 : 770151 : DISPATCH();
3441 : : }
3442 : :
3443 : 243800 : TARGET(DICT_UPDATE) {
3444 : 243800 : PyObject *update = POP();
3445 : 243800 : PyObject *dict = PEEK(oparg);
3446 [ + + ]: 243800 : if (PyDict_Update(dict, update) < 0) {
3447 [ + + ]: 3 : if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
3448 : 2 : _PyErr_Format(tstate, PyExc_TypeError,
3449 : : "'%.200s' object is not a mapping",
3450 : 2 : Py_TYPE(update)->tp_name);
3451 : : }
3452 [ + + ]: 3 : Py_DECREF(update);
3453 : 3 : goto error;
3454 : : }
3455 [ + + ]: 243797 : Py_DECREF(update);
3456 : 243797 : DISPATCH();
3457 : : }
3458 : :
3459 : 3401440 : TARGET(DICT_MERGE) {
3460 : 3401440 : PyObject *update = POP();
3461 : 3401440 : PyObject *dict = PEEK(oparg);
3462 : :
3463 [ + + ]: 3401440 : if (_PyDict_MergeEx(dict, update, 2) < 0) {
3464 : 23 : format_kwargs_error(tstate, PEEK(2 + oparg), update);
3465 [ + + ]: 23 : Py_DECREF(update);
3466 : 23 : goto error;
3467 : : }
3468 [ + + ]: 3401417 : Py_DECREF(update);
3469 : : PREDICT(CALL_FUNCTION_EX);
3470 : 3401417 : DISPATCH();
3471 : : }
3472 : :
3473 : 4800154 : TARGET(MAP_ADD) {
3474 : 4800154 : PyObject *value = TOP();
3475 : 4800154 : PyObject *key = SECOND();
3476 : : PyObject *map;
3477 : 4800154 : STACK_SHRINK(2);
3478 : 4800154 : map = PEEK(oparg); /* dict */
3479 : : assert(PyDict_CheckExact(map));
3480 : : /* map[key] = value */
3481 [ + + ]: 4800154 : if (_PyDict_SetItem_Take2((PyDictObject *)map, key, value) != 0) {
3482 : 1 : goto error;
3483 : : }
3484 : : PREDICT(JUMP_BACKWARD_QUICK);
3485 : 4800153 : DISPATCH();
3486 : : }
3487 : :
3488 : 48275093 : TARGET(LOAD_ATTR) {
3489 : 158701907 : PREDICTED(LOAD_ATTR);
3490 : 158701907 : PyObject *name = GETITEM(names, oparg >> 1);
3491 : 158701907 : PyObject *owner = TOP();
3492 [ + + ]: 158701907 : if (oparg & 1) {
3493 : : /* Designed to work in tandem with CALL. */
3494 : 38292694 : PyObject* meth = NULL;
3495 : :
3496 : 38292694 : int meth_found = _PyObject_GetMethod(owner, name, &meth);
3497 : :
3498 [ + + ]: 38292694 : if (meth == NULL) {
3499 : : /* Most likely attribute wasn't found. */
3500 : 5541 : goto error;
3501 : : }
3502 : :
3503 [ + + ]: 38287153 : if (meth_found) {
3504 : : /* We can bypass temporary bound method object.
3505 : : meth is unbound method and obj is self.
3506 : :
3507 : : meth | self | arg1 | ... | argN
3508 : : */
3509 : 23273756 : SET_TOP(meth);
3510 : 23273756 : PUSH(owner); // self
3511 : : }
3512 : : else {
3513 : : /* meth is not an unbound method (but a regular attr, or
3514 : : something was returned by a descriptor protocol). Set
3515 : : the second element of the stack to NULL, to signal
3516 : : CALL that it's not a method call.
3517 : :
3518 : : NULL | meth | arg1 | ... | argN
3519 : : */
3520 : 15013397 : SET_TOP(NULL);
3521 [ + + ]: 15013397 : Py_DECREF(owner);
3522 : 15013397 : PUSH(meth);
3523 : : }
3524 : 38287153 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
3525 : 38287153 : DISPATCH();
3526 : : }
3527 : 120409213 : PyObject *res = PyObject_GetAttr(owner, name);
3528 [ + + ]: 120409205 : if (res == NULL) {
3529 : 171851 : goto error;
3530 : : }
3531 [ + + ]: 120237354 : Py_DECREF(owner);
3532 : 120237354 : SET_TOP(res);
3533 : 120237354 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
3534 : 120237354 : DISPATCH();
3535 : : }
3536 : :
3537 : 113457673 : TARGET(LOAD_ATTR_ADAPTIVE) {
3538 : : assert(cframe.use_tracing == 0);
3539 : 113457673 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3540 [ + + ]: 113457673 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
3541 : 3030859 : PyObject *owner = TOP();
3542 : 3030859 : PyObject *name = GETITEM(names, oparg>>1);
3543 : 3030859 : next_instr--;
3544 [ - + ]: 3030859 : if (_Py_Specialize_LoadAttr(owner, next_instr, name) < 0) {
3545 : 0 : goto error;
3546 : : }
3547 : 3030859 : NOTRACE_DISPATCH_SAME_OPARG();
3548 : : }
3549 : : else {
3550 : : STAT_INC(LOAD_ATTR, deferred);
3551 : 110426814 : DECREMENT_ADAPTIVE_COUNTER(cache);
3552 : 110426814 : JUMP_TO_INSTRUCTION(LOAD_ATTR);
3553 : : }
3554 : : }
3555 : :
3556 : 201936596 : TARGET(LOAD_ATTR_INSTANCE_VALUE) {
3557 : : assert(cframe.use_tracing == 0);
3558 : 201936596 : PyObject *owner = TOP();
3559 : : PyObject *res;
3560 : 201936596 : PyTypeObject *tp = Py_TYPE(owner);
3561 : 201936596 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3562 : 201936596 : uint32_t type_version = read_u32(cache->version);
3563 : : assert(type_version != 0);
3564 [ + + ]: 201936596 : DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
3565 : : assert(tp->tp_dictoffset < 0);
3566 : : assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
3567 : 198343935 : PyDictValues *values = *_PyObject_ValuesPointer(owner);
3568 [ + + ]: 198343935 : DEOPT_IF(values == NULL, LOAD_ATTR);
3569 : 198161020 : res = values->values[cache->index];
3570 [ + + ]: 198161020 : DEOPT_IF(res == NULL, LOAD_ATTR);
3571 : : STAT_INC(LOAD_ATTR, hit);
3572 : 197614280 : Py_INCREF(res);
3573 : 197614280 : SET_TOP(NULL);
3574 : 197614280 : STACK_GROW((oparg & 1));
3575 : 197614280 : SET_TOP(res);
3576 [ + + ]: 197614280 : Py_DECREF(owner);
3577 : 197614280 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
3578 : 197614280 : NOTRACE_DISPATCH();
3579 : : }
3580 : :
3581 : 63374853 : TARGET(LOAD_ATTR_MODULE) {
3582 : : assert(cframe.use_tracing == 0);
3583 : 63374853 : PyObject *owner = TOP();
3584 : : PyObject *res;
3585 : 63374853 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3586 [ + + ]: 63374853 : DEOPT_IF(!PyModule_CheckExact(owner), LOAD_ATTR);
3587 : 63374323 : PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner)->md_dict;
3588 : : assert(dict != NULL);
3589 [ + + ]: 63374323 : DEOPT_IF(dict->ma_keys->dk_version != read_u32(cache->version),
3590 : : LOAD_ATTR);
3591 : : assert(dict->ma_keys->dk_kind == DICT_KEYS_UNICODE);
3592 : : assert(cache->index < dict->ma_keys->dk_nentries);
3593 : 61202926 : PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + cache->index;
3594 : 61202926 : res = ep->me_value;
3595 [ - + ]: 61202926 : DEOPT_IF(res == NULL, LOAD_ATTR);
3596 : : STAT_INC(LOAD_ATTR, hit);
3597 : 61202926 : Py_INCREF(res);
3598 : 61202926 : SET_TOP(NULL);
3599 : 61202926 : STACK_GROW((oparg & 1));
3600 : 61202926 : SET_TOP(res);
3601 [ - + ]: 61202926 : Py_DECREF(owner);
3602 : 61202926 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
3603 : 61202926 : NOTRACE_DISPATCH();
3604 : : }
3605 : :
3606 : 11232885 : TARGET(LOAD_ATTR_WITH_HINT) {
3607 : : assert(cframe.use_tracing == 0);
3608 : 11232885 : PyObject *owner = TOP();
3609 : : PyObject *res;
3610 : 11232885 : PyTypeObject *tp = Py_TYPE(owner);
3611 : 11232885 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3612 : 11232885 : uint32_t type_version = read_u32(cache->version);
3613 : : assert(type_version != 0);
3614 [ + + ]: 11232885 : DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
3615 : : assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
3616 : 10739701 : PyDictObject *dict = *(PyDictObject **)_PyObject_ManagedDictPointer(owner);
3617 [ + + ]: 10739701 : DEOPT_IF(dict == NULL, LOAD_ATTR);
3618 : : assert(PyDict_CheckExact((PyObject *)dict));
3619 : 10618294 : PyObject *name = GETITEM(names, oparg>>1);
3620 : 10618294 : uint16_t hint = cache->index;
3621 [ + + ]: 10618294 : DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, LOAD_ATTR);
3622 [ + - ]: 10603200 : if (DK_IS_UNICODE(dict->ma_keys)) {
3623 : 10603200 : PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint;
3624 [ + + ]: 10603200 : DEOPT_IF(ep->me_key != name, LOAD_ATTR);
3625 : 10546023 : res = ep->me_value;
3626 : : }
3627 : : else {
3628 : 0 : PyDictKeyEntry *ep = DK_ENTRIES(dict->ma_keys) + hint;
3629 [ # # ]: 0 : DEOPT_IF(ep->me_key != name, LOAD_ATTR);
3630 : 0 : res = ep->me_value;
3631 : : }
3632 [ + + ]: 10546023 : DEOPT_IF(res == NULL, LOAD_ATTR);
3633 : : STAT_INC(LOAD_ATTR, hit);
3634 : 6483325 : Py_INCREF(res);
3635 : 6483325 : SET_TOP(NULL);
3636 : 6483325 : STACK_GROW((oparg & 1));
3637 : 6483325 : SET_TOP(res);
3638 [ - + ]: 6483325 : Py_DECREF(owner);
3639 : 6483325 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
3640 : 6483325 : NOTRACE_DISPATCH();
3641 : : }
3642 : :
3643 : 46411412 : TARGET(LOAD_ATTR_SLOT) {
3644 : : assert(cframe.use_tracing == 0);
3645 : 46411412 : PyObject *owner = TOP();
3646 : : PyObject *res;
3647 : 46411412 : PyTypeObject *tp = Py_TYPE(owner);
3648 : 46411412 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3649 : 46411412 : uint32_t type_version = read_u32(cache->version);
3650 : : assert(type_version != 0);
3651 [ + + ]: 46411412 : DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
3652 : 43827955 : char *addr = (char *)owner + cache->index;
3653 : 43827955 : res = *(PyObject **)addr;
3654 [ + + ]: 43827955 : DEOPT_IF(res == NULL, LOAD_ATTR);
3655 : : STAT_INC(LOAD_ATTR, hit);
3656 : 43799656 : Py_INCREF(res);
3657 : 43799656 : SET_TOP(NULL);
3658 : 43799656 : STACK_GROW((oparg & 1));
3659 : 43799656 : SET_TOP(res);
3660 [ + + ]: 43799656 : Py_DECREF(owner);
3661 : 43799656 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
3662 : 43799656 : NOTRACE_DISPATCH();
3663 : : }
3664 : :
3665 : 7589214 : TARGET(LOAD_ATTR_CLASS) {
3666 : : assert(cframe.use_tracing == 0);
3667 : 7589214 : _PyLoadMethodCache *cache = (_PyLoadMethodCache *)next_instr;
3668 : :
3669 : 7589214 : PyObject *cls = TOP();
3670 [ + + ]: 7589214 : DEOPT_IF(!PyType_Check(cls), LOAD_ATTR);
3671 : 7589156 : uint32_t type_version = read_u32(cache->type_version);
3672 [ + + ]: 7589156 : DEOPT_IF(((PyTypeObject *)cls)->tp_version_tag != type_version,
3673 : : LOAD_ATTR);
3674 : : assert(type_version != 0);
3675 : :
3676 : : STAT_INC(LOAD_ATTR, hit);
3677 : 2222416 : PyObject *res = read_obj(cache->descr);
3678 : : assert(res != NULL);
3679 : 2222416 : Py_INCREF(res);
3680 : 2222416 : SET_TOP(NULL);
3681 : 2222416 : STACK_GROW((oparg & 1));
3682 : 2222416 : SET_TOP(res);
3683 [ - + ]: 2222416 : Py_DECREF(cls);
3684 : 2222416 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
3685 : 2222416 : NOTRACE_DISPATCH();
3686 : : }
3687 : :
3688 : 5788346 : TARGET(LOAD_ATTR_PROPERTY) {
3689 : : assert(cframe.use_tracing == 0);
3690 [ - + ]: 5788346 : DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR);
3691 : 5788346 : _PyLoadMethodCache *cache = (_PyLoadMethodCache *)next_instr;
3692 : :
3693 : 5788346 : PyObject *owner = TOP();
3694 : 5788346 : PyTypeObject *cls = Py_TYPE(owner);
3695 : 5788346 : uint32_t type_version = read_u32(cache->type_version);
3696 [ + + ]: 5788346 : DEOPT_IF(cls->tp_version_tag != type_version, LOAD_ATTR);
3697 : : assert(type_version != 0);
3698 : 5651382 : PyObject *fget = read_obj(cache->descr);
3699 : 5651382 : PyFunctionObject *f = (PyFunctionObject *)fget;
3700 : 5651382 : uint32_t func_version = read_u32(cache->keys_version);
3701 : : assert(func_version != 0);
3702 [ - + ]: 5651382 : DEOPT_IF(f->func_version != func_version, LOAD_ATTR);
3703 : 5651382 : PyCodeObject *code = (PyCodeObject *)f->func_code;
3704 : : assert(code->co_argcount == 1);
3705 [ + + ]: 5651382 : DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), LOAD_ATTR);
3706 : : STAT_INC(LOAD_ATTR, hit);
3707 : 5651343 : Py_INCREF(fget);
3708 : 5651343 : _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f);
3709 : 5651343 : SET_TOP(NULL);
3710 : 5651343 : int push_null = !(oparg & 1);
3711 : 5651343 : STACK_SHRINK(push_null);
3712 : 5651343 : new_frame->localsplus[0] = owner;
3713 [ + + ]: 5784167 : for (int i = 1; i < code->co_nlocalsplus; i++) {
3714 : 132824 : new_frame->localsplus[i] = NULL;
3715 : : }
3716 : 5651343 : _PyFrame_SetStackPointer(frame, stack_pointer);
3717 : 5651343 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
3718 : 5651343 : frame->prev_instr = next_instr - 1;
3719 : 5651343 : new_frame->previous = frame;
3720 : 5651343 : frame = cframe.current_frame = new_frame;
3721 : : CALL_STAT_INC(inlined_py_calls);
3722 : 5651343 : goto start_frame;
3723 : : }
3724 : :
3725 : 19472085 : TARGET(STORE_ATTR_ADAPTIVE) {
3726 : : assert(cframe.use_tracing == 0);
3727 : 19472085 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3728 [ + + ]: 19472085 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
3729 : 702398 : PyObject *owner = TOP();
3730 : 702398 : PyObject *name = GETITEM(names, oparg);
3731 : 702398 : next_instr--;
3732 [ - + ]: 702398 : if (_Py_Specialize_StoreAttr(owner, next_instr, name) < 0) {
3733 : 0 : goto error;
3734 : : }
3735 : 702398 : NOTRACE_DISPATCH_SAME_OPARG();
3736 : : }
3737 : : else {
3738 : : STAT_INC(STORE_ATTR, deferred);
3739 : 18769687 : DECREMENT_ADAPTIVE_COUNTER(cache);
3740 : 18769687 : JUMP_TO_INSTRUCTION(STORE_ATTR);
3741 : : }
3742 : : }
3743 : :
3744 : 53731898 : TARGET(STORE_ATTR_INSTANCE_VALUE) {
3745 : : assert(cframe.use_tracing == 0);
3746 : 53731898 : PyObject *owner = TOP();
3747 : 53731898 : PyTypeObject *tp = Py_TYPE(owner);
3748 : 53731898 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3749 : 53731898 : uint32_t type_version = read_u32(cache->version);
3750 : : assert(type_version != 0);
3751 [ + + ]: 53731898 : DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
3752 : : assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
3753 : 49982921 : PyDictValues *values = *_PyObject_ValuesPointer(owner);
3754 [ + + ]: 49982921 : DEOPT_IF(values == NULL, STORE_ATTR);
3755 : : STAT_INC(STORE_ATTR, hit);
3756 : 49885707 : Py_ssize_t index = cache->index;
3757 : 49885707 : STACK_SHRINK(1);
3758 : 49885707 : PyObject *value = POP();
3759 : 49885707 : PyObject *old_value = values->values[index];
3760 : 49885707 : values->values[index] = value;
3761 [ + + ]: 49885707 : if (old_value == NULL) {
3762 : 27265945 : _PyDictValues_AddToInsertionOrder(values, index);
3763 : : }
3764 : : else {
3765 [ + + ]: 22619762 : Py_DECREF(old_value);
3766 : : }
3767 [ - + ]: 49885707 : Py_DECREF(owner);
3768 : 49885707 : JUMPBY(INLINE_CACHE_ENTRIES_STORE_ATTR);
3769 : 49885707 : NOTRACE_DISPATCH();
3770 : : }
3771 : :
3772 : 654295 : TARGET(STORE_ATTR_WITH_HINT) {
3773 : : assert(cframe.use_tracing == 0);
3774 : 654295 : PyObject *owner = TOP();
3775 : 654295 : PyTypeObject *tp = Py_TYPE(owner);
3776 : 654295 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3777 : 654295 : uint32_t type_version = read_u32(cache->version);
3778 : : assert(type_version != 0);
3779 [ + + ]: 654295 : DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
3780 : : assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
3781 : 399315 : PyDictObject *dict = *(PyDictObject **)_PyObject_ManagedDictPointer(owner);
3782 [ + + ]: 399315 : DEOPT_IF(dict == NULL, STORE_ATTR);
3783 : : assert(PyDict_CheckExact((PyObject *)dict));
3784 : 385974 : PyObject *name = GETITEM(names, oparg);
3785 : 385974 : uint16_t hint = cache->index;
3786 [ + + ]: 385974 : DEOPT_IF(hint >= (size_t)dict->ma_keys->dk_nentries, STORE_ATTR);
3787 : : PyObject *value, *old_value;
3788 [ + - ]: 382983 : if (DK_IS_UNICODE(dict->ma_keys)) {
3789 : 382983 : PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint;
3790 [ + + ]: 382983 : DEOPT_IF(ep->me_key != name, STORE_ATTR);
3791 : 365126 : old_value = ep->me_value;
3792 [ + + ]: 365126 : DEOPT_IF(old_value == NULL, STORE_ATTR);
3793 : 71406 : STACK_SHRINK(1);
3794 : 71406 : value = POP();
3795 : 71406 : ep->me_value = value;
3796 : : }
3797 : : else {
3798 : 0 : PyDictKeyEntry *ep = DK_ENTRIES(dict->ma_keys) + hint;
3799 [ # # ]: 0 : DEOPT_IF(ep->me_key != name, STORE_ATTR);
3800 : 0 : old_value = ep->me_value;
3801 [ # # ]: 0 : DEOPT_IF(old_value == NULL, STORE_ATTR);
3802 : 0 : STACK_SHRINK(1);
3803 : 0 : value = POP();
3804 : 0 : ep->me_value = value;
3805 : : }
3806 [ + + ]: 71406 : Py_DECREF(old_value);
3807 : : STAT_INC(STORE_ATTR, hit);
3808 : : /* Ensure dict is GC tracked if it needs to be */
3809 [ - + - - ]: 71406 : if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(value)) {
3810 : 0 : _PyObject_GC_TRACK(dict);
3811 : : }
3812 : : /* PEP 509 */
3813 : 71406 : dict->ma_version_tag = DICT_NEXT_VERSION();
3814 [ - + ]: 71406 : Py_DECREF(owner);
3815 : 71406 : JUMPBY(INLINE_CACHE_ENTRIES_STORE_ATTR);
3816 : 71406 : NOTRACE_DISPATCH();
3817 : : }
3818 : :
3819 : 8394848 : TARGET(STORE_ATTR_SLOT) {
3820 : : assert(cframe.use_tracing == 0);
3821 : 8394848 : PyObject *owner = TOP();
3822 : 8394848 : PyTypeObject *tp = Py_TYPE(owner);
3823 : 8394848 : _PyAttrCache *cache = (_PyAttrCache *)next_instr;
3824 : 8394848 : uint32_t type_version = read_u32(cache->version);
3825 : : assert(type_version != 0);
3826 [ + + ]: 8394848 : DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR);
3827 : 8303478 : char *addr = (char *)owner + cache->index;
3828 : : STAT_INC(STORE_ATTR, hit);
3829 : 8303478 : STACK_SHRINK(1);
3830 : 8303478 : PyObject *value = POP();
3831 : 8303478 : PyObject *old_value = *(PyObject **)addr;
3832 : 8303478 : *(PyObject **)addr = value;
3833 [ + + + + ]: 8303478 : Py_XDECREF(old_value);
3834 [ - + ]: 8303478 : Py_DECREF(owner);
3835 : 8303478 : JUMPBY(INLINE_CACHE_ENTRIES_STORE_ATTR);
3836 : 8303478 : NOTRACE_DISPATCH();
3837 : : }
3838 : :
3839 : 32199017 : TARGET(COMPARE_OP) {
3840 : 55845652 : PREDICTED(COMPARE_OP);
3841 : : assert(oparg <= Py_GE);
3842 : 55845652 : PyObject *right = POP();
3843 : 55845652 : PyObject *left = TOP();
3844 : 55845652 : PyObject *res = PyObject_RichCompare(left, right, oparg);
3845 : 55845652 : SET_TOP(res);
3846 [ + + ]: 55845652 : Py_DECREF(left);
3847 [ + + ]: 55845652 : Py_DECREF(right);
3848 [ + + ]: 55845652 : if (res == NULL) {
3849 : 6678 : goto error;
3850 : : }
3851 : 55838974 : JUMPBY(INLINE_CACHE_ENTRIES_COMPARE_OP);
3852 : 55838974 : DISPATCH();
3853 : : }
3854 : :
3855 : 24056299 : TARGET(COMPARE_OP_ADAPTIVE) {
3856 : : assert(cframe.use_tracing == 0);
3857 : 24056299 : _PyCompareOpCache *cache = (_PyCompareOpCache *)next_instr;
3858 [ + + ]: 24056299 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
3859 : 409664 : PyObject *right = TOP();
3860 : 409664 : PyObject *left = SECOND();
3861 : 409664 : next_instr--;
3862 : 409664 : _Py_Specialize_CompareOp(left, right, next_instr, oparg);
3863 : 409664 : NOTRACE_DISPATCH_SAME_OPARG();
3864 : : }
3865 : : else {
3866 : : STAT_INC(COMPARE_OP, deferred);
3867 : 23646635 : DECREMENT_ADAPTIVE_COUNTER(cache);
3868 : 23646635 : JUMP_TO_INSTRUCTION(COMPARE_OP);
3869 : : }
3870 : : }
3871 : :
3872 : 12550999 : TARGET(COMPARE_OP_FLOAT_JUMP) {
3873 : : assert(cframe.use_tracing == 0);
3874 : : // Combined: COMPARE_OP (float ? float) + POP_JUMP_(direction)_IF_(true/false)
3875 : 12550999 : _PyCompareOpCache *cache = (_PyCompareOpCache *)next_instr;
3876 : 12550999 : int when_to_jump_mask = cache->mask;
3877 : 12550999 : PyObject *right = TOP();
3878 : 12550999 : PyObject *left = SECOND();
3879 [ + + ]: 12550999 : DEOPT_IF(!PyFloat_CheckExact(left), COMPARE_OP);
3880 [ + + ]: 12544895 : DEOPT_IF(!PyFloat_CheckExact(right), COMPARE_OP);
3881 : 12527867 : double dleft = PyFloat_AS_DOUBLE(left);
3882 : 12527867 : double dright = PyFloat_AS_DOUBLE(right);
3883 : 12527867 : int sign = (dleft > dright) - (dleft < dright);
3884 [ + + ]: 12527867 : DEOPT_IF(isnan(dleft), COMPARE_OP);
3885 [ - + ]: 12527688 : DEOPT_IF(isnan(dright), COMPARE_OP);
3886 : : STAT_INC(COMPARE_OP, hit);
3887 : 12527688 : JUMPBY(INLINE_CACHE_ENTRIES_COMPARE_OP);
3888 : 12527688 : NEXTOPARG();
3889 : 12527688 : STACK_SHRINK(2);
3890 [ + + ]: 12527688 : _Py_DECREF_SPECIALIZED(left, _PyFloat_ExactDealloc);
3891 [ + + ]: 12527688 : _Py_DECREF_SPECIALIZED(right, _PyFloat_ExactDealloc);
3892 : : assert(opcode == POP_JUMP_FORWARD_IF_FALSE ||
3893 : : opcode == POP_JUMP_BACKWARD_IF_FALSE ||
3894 : : opcode == POP_JUMP_FORWARD_IF_TRUE ||
3895 : : opcode == POP_JUMP_BACKWARD_IF_TRUE);
3896 : 12527688 : int jump = (9 << (sign + 1)) & when_to_jump_mask;
3897 [ + + ]: 12527688 : if (!jump) {
3898 : 4983640 : next_instr++;
3899 : : }
3900 [ + + ]: 7544048 : else if (jump >= 8) {
3901 : : assert(opcode == POP_JUMP_BACKWARD_IF_TRUE ||
3902 : : opcode == POP_JUMP_BACKWARD_IF_FALSE);
3903 : 61524 : JUMPBY(1 - oparg);
3904 [ - + ]: 61524 : CHECK_EVAL_BREAKER();
3905 : : }
3906 : : else {
3907 : : assert(opcode == POP_JUMP_FORWARD_IF_TRUE ||
3908 : : opcode == POP_JUMP_FORWARD_IF_FALSE);
3909 : 7482524 : JUMPBY(1 + oparg);
3910 : : }
3911 : 12527688 : NOTRACE_DISPATCH();
3912 : : }
3913 : :
3914 : 125643439 : TARGET(COMPARE_OP_INT_JUMP) {
3915 : : assert(cframe.use_tracing == 0);
3916 : : // Combined: COMPARE_OP (int ? int) + POP_JUMP_(direction)_IF_(true/false)
3917 : 125643439 : _PyCompareOpCache *cache = (_PyCompareOpCache *)next_instr;
3918 : 125643439 : int when_to_jump_mask = cache->mask;
3919 : 125643439 : PyObject *right = TOP();
3920 : 125643439 : PyObject *left = SECOND();
3921 [ + + ]: 125643439 : DEOPT_IF(!PyLong_CheckExact(left), COMPARE_OP);
3922 [ + + ]: 125452328 : DEOPT_IF(!PyLong_CheckExact(right), COMPARE_OP);
3923 [ + + ]: 125444199 : DEOPT_IF((size_t)(Py_SIZE(left) + 1) > 2, COMPARE_OP);
3924 [ + + ]: 125117266 : DEOPT_IF((size_t)(Py_SIZE(right) + 1) > 2, COMPARE_OP);
3925 : : STAT_INC(COMPARE_OP, hit);
3926 : : assert(Py_ABS(Py_SIZE(left)) <= 1 && Py_ABS(Py_SIZE(right)) <= 1);
3927 : 124926380 : Py_ssize_t ileft = Py_SIZE(left) * ((PyLongObject *)left)->ob_digit[0];
3928 : 124926380 : Py_ssize_t iright = Py_SIZE(right) * ((PyLongObject *)right)->ob_digit[0];
3929 : 124926380 : int sign = (ileft > iright) - (ileft < iright);
3930 : 124926380 : JUMPBY(INLINE_CACHE_ENTRIES_COMPARE_OP);
3931 : 124926380 : NEXTOPARG();
3932 : 124926380 : STACK_SHRINK(2);
3933 [ + + ]: 124926380 : _Py_DECREF_SPECIALIZED(left, (destructor)PyObject_Free);
3934 [ + + ]: 124926380 : _Py_DECREF_SPECIALIZED(right, (destructor)PyObject_Free);
3935 : : assert(opcode == POP_JUMP_FORWARD_IF_FALSE ||
3936 : : opcode == POP_JUMP_BACKWARD_IF_FALSE ||
3937 : : opcode == POP_JUMP_FORWARD_IF_TRUE ||
3938 : : opcode == POP_JUMP_BACKWARD_IF_TRUE);
3939 : 124926380 : int jump = (9 << (sign + 1)) & when_to_jump_mask;
3940 [ + + ]: 124926380 : if (!jump) {
3941 : 36271359 : next_instr++;
3942 : : }
3943 [ + + ]: 88655021 : else if (jump >= 8) {
3944 : : assert(opcode == POP_JUMP_BACKWARD_IF_TRUE ||
3945 : : opcode == POP_JUMP_BACKWARD_IF_FALSE);
3946 : 15101906 : JUMPBY(1 - oparg);
3947 [ + + ]: 15101906 : CHECK_EVAL_BREAKER();
3948 : : }
3949 : : else {
3950 : : assert(opcode == POP_JUMP_FORWARD_IF_TRUE ||
3951 : : opcode == POP_JUMP_FORWARD_IF_FALSE);
3952 : 73553115 : JUMPBY(1 + oparg);
3953 : : }
3954 : 124926375 : NOTRACE_DISPATCH();
3955 : : }
3956 : :
3957 : 52584727 : TARGET(COMPARE_OP_STR_JUMP) {
3958 : : assert(cframe.use_tracing == 0);
3959 : : // Combined: COMPARE_OP (str == str or str != str) + POP_JUMP_(direction)_IF_(true/false)
3960 : 52584727 : _PyCompareOpCache *cache = (_PyCompareOpCache *)next_instr;
3961 : 52584727 : int when_to_jump_mask = cache->mask;
3962 : 52584727 : PyObject *right = TOP();
3963 : 52584727 : PyObject *left = SECOND();
3964 [ + + ]: 52584727 : DEOPT_IF(!PyUnicode_CheckExact(left), COMPARE_OP);
3965 [ + + ]: 52532060 : DEOPT_IF(!PyUnicode_CheckExact(right), COMPARE_OP);
3966 : : STAT_INC(COMPARE_OP, hit);
3967 : 52476194 : int res = _PyUnicode_Equal(left, right);
3968 [ - + ]: 52476194 : if (res < 0) {
3969 : 0 : goto error;
3970 : : }
3971 : : assert(oparg == Py_EQ || oparg == Py_NE);
3972 : 52476194 : JUMPBY(INLINE_CACHE_ENTRIES_COMPARE_OP);
3973 : 52476194 : NEXTOPARG();
3974 : : assert(opcode == POP_JUMP_FORWARD_IF_FALSE ||
3975 : : opcode == POP_JUMP_BACKWARD_IF_FALSE ||
3976 : : opcode == POP_JUMP_FORWARD_IF_TRUE ||
3977 : : opcode == POP_JUMP_BACKWARD_IF_TRUE);
3978 : 52476194 : STACK_SHRINK(2);
3979 [ + + ]: 52476194 : _Py_DECREF_SPECIALIZED(left, _PyUnicode_ExactDealloc);
3980 [ + + ]: 52476194 : _Py_DECREF_SPECIALIZED(right, _PyUnicode_ExactDealloc);
3981 : : assert(res == 0 || res == 1);
3982 : 52476194 : int sign = 1 - res;
3983 : 52476194 : int jump = (9 << (sign + 1)) & when_to_jump_mask;
3984 [ + + ]: 52476194 : if (!jump) {
3985 : 13209275 : next_instr++;
3986 : : }
3987 [ + + ]: 39266919 : else if (jump >= 8) {
3988 : : assert(opcode == POP_JUMP_BACKWARD_IF_TRUE ||
3989 : : opcode == POP_JUMP_BACKWARD_IF_FALSE);
3990 : 4602067 : JUMPBY(1 - oparg);
3991 [ - + ]: 4602067 : CHECK_EVAL_BREAKER();
3992 : : }
3993 : : else {
3994 : : assert(opcode == POP_JUMP_FORWARD_IF_TRUE ||
3995 : : opcode == POP_JUMP_FORWARD_IF_FALSE);
3996 : 34664852 : JUMPBY(1 + oparg);
3997 : : }
3998 : 52476194 : NOTRACE_DISPATCH();
3999 : : }
4000 : :
4001 : 34584338 : TARGET(IS_OP) {
4002 : 34584338 : PyObject *right = POP();
4003 : 34584338 : PyObject *left = TOP();
4004 : 34584338 : int res = Py_Is(left, right) ^ oparg;
4005 [ + + ]: 34584338 : PyObject *b = res ? Py_True : Py_False;
4006 : 34584338 : Py_INCREF(b);
4007 : 34584338 : SET_TOP(b);
4008 [ + + ]: 34584338 : Py_DECREF(left);
4009 [ + + ]: 34584338 : Py_DECREF(right);
4010 : 34584338 : DISPATCH();
4011 : : }
4012 : :
4013 : 91079072 : TARGET(CONTAINS_OP) {
4014 : 91079072 : PyObject *right = POP();
4015 : 91079072 : PyObject *left = POP();
4016 : 91079072 : int res = PySequence_Contains(right, left);
4017 [ + + ]: 91079072 : Py_DECREF(left);
4018 [ + + ]: 91079072 : Py_DECREF(right);
4019 [ + + ]: 91079072 : if (res < 0) {
4020 : 60 : goto error;
4021 : : }
4022 [ + + ]: 91079012 : PyObject *b = (res^oparg) ? Py_True : Py_False;
4023 : 91079012 : Py_INCREF(b);
4024 : 91079012 : PUSH(b);
4025 : 91079012 : DISPATCH();
4026 : : }
4027 : :
4028 : 179 : TARGET(CHECK_EG_MATCH) {
4029 : 179 : PyObject *match_type = POP();
4030 [ + + ]: 179 : if (check_except_star_type_valid(tstate, match_type) < 0) {
4031 [ + + ]: 4 : Py_DECREF(match_type);
4032 : 4 : goto error;
4033 : : }
4034 : :
4035 : 175 : PyObject *exc_value = TOP();
4036 : 175 : PyObject *match = NULL, *rest = NULL;
4037 : 175 : int res = exception_group_match(exc_value, match_type,
4038 : : &match, &rest);
4039 [ + + ]: 175 : Py_DECREF(match_type);
4040 [ - + ]: 175 : if (res < 0) {
4041 : 0 : goto error;
4042 : : }
4043 : :
4044 [ + - - + ]: 175 : if (match == NULL || rest == NULL) {
4045 : : assert(match == NULL);
4046 : : assert(rest == NULL);
4047 : 0 : goto error;
4048 : : }
4049 [ + + ]: 175 : if (Py_IsNone(match)) {
4050 : 27 : PUSH(match);
4051 [ + - + + ]: 27 : Py_XDECREF(rest);
4052 : : }
4053 : : else {
4054 : : /* Total or partial match - update the stack from
4055 : : * [val]
4056 : : * to
4057 : : * [rest, match]
4058 : : * (rest can be Py_None)
4059 : : */
4060 : :
4061 : 148 : SET_TOP(rest);
4062 : 148 : PUSH(match);
4063 : 148 : PyErr_SetExcInfo(NULL, Py_NewRef(match), NULL);
4064 [ + + ]: 148 : Py_DECREF(exc_value);
4065 : : }
4066 : 175 : DISPATCH();
4067 : : }
4068 : :
4069 : 3558611 : TARGET(CHECK_EXC_MATCH) {
4070 : 3558611 : PyObject *right = POP();
4071 : 3558611 : PyObject *left = TOP();
4072 : : assert(PyExceptionInstance_Check(left));
4073 [ + + ]: 3558611 : if (check_except_type_valid(tstate, right) < 0) {
4074 [ + + ]: 10 : Py_DECREF(right);
4075 : 10 : goto error;
4076 : : }
4077 : :
4078 : 3558601 : int res = PyErr_GivenExceptionMatches(left, right);
4079 [ + + ]: 3558601 : Py_DECREF(right);
4080 [ + + ]: 3558601 : PUSH(Py_NewRef(res ? Py_True : Py_False));
4081 : 3558601 : DISPATCH();
4082 : : }
4083 : :
4084 : 1443142 : TARGET(IMPORT_NAME) {
4085 : 1443142 : PyObject *name = GETITEM(names, oparg);
4086 : 1443142 : PyObject *fromlist = POP();
4087 : 1443142 : PyObject *level = TOP();
4088 : : PyObject *res;
4089 : 1443142 : res = import_name(tstate, frame, name, fromlist, level);
4090 [ - + ]: 1443142 : Py_DECREF(level);
4091 [ - + ]: 1443142 : Py_DECREF(fromlist);
4092 : 1443142 : SET_TOP(res);
4093 [ + + ]: 1443142 : if (res == NULL)
4094 : 14772 : goto error;
4095 : 1428370 : DISPATCH();
4096 : : }
4097 : :
4098 : 40974 : TARGET(IMPORT_STAR) {
4099 : 40974 : PyObject *from = POP(), *locals;
4100 : : int err;
4101 [ - + ]: 40974 : if (_PyFrame_FastToLocalsWithError(frame) < 0) {
4102 [ # # ]: 0 : Py_DECREF(from);
4103 : 0 : goto error;
4104 : : }
4105 : :
4106 : 40974 : locals = LOCALS();
4107 [ - + ]: 40974 : if (locals == NULL) {
4108 : 0 : _PyErr_SetString(tstate, PyExc_SystemError,
4109 : : "no locals found during 'import *'");
4110 [ # # ]: 0 : Py_DECREF(from);
4111 : 0 : goto error;
4112 : : }
4113 : 40974 : err = import_all_from(tstate, locals, from);
4114 : 40974 : _PyFrame_LocalsToFast(frame, 0);
4115 [ - + ]: 40974 : Py_DECREF(from);
4116 [ + + ]: 40974 : if (err != 0)
4117 : 2 : goto error;
4118 : 40972 : DISPATCH();
4119 : : }
4120 : :
4121 : 807403 : TARGET(IMPORT_FROM) {
4122 : 807403 : PyObject *name = GETITEM(names, oparg);
4123 : 807403 : PyObject *from = TOP();
4124 : : PyObject *res;
4125 : 807403 : res = import_from(tstate, from, name);
4126 : 807403 : PUSH(res);
4127 [ + + ]: 807403 : if (res == NULL)
4128 : 4763 : goto error;
4129 : 802640 : DISPATCH();
4130 : : }
4131 : :
4132 : 32949476 : TARGET(JUMP_FORWARD) {
4133 : 32949476 : JUMPBY(oparg);
4134 : 32949476 : DISPATCH();
4135 : : }
4136 : :
4137 : 1125204 : TARGET(JUMP_BACKWARD) {
4138 : 1125204 : _PyCode_Warmup(frame->f_code);
4139 : 1125204 : JUMP_TO_INSTRUCTION(JUMP_BACKWARD_QUICK);
4140 : : }
4141 : :
4142 : 37855824 : TARGET(POP_JUMP_BACKWARD_IF_FALSE) {
4143 : 37855824 : PREDICTED(POP_JUMP_BACKWARD_IF_FALSE);
4144 : 37855824 : PyObject *cond = POP();
4145 [ + + ]: 37855824 : if (Py_IsTrue(cond)) {
4146 : 7630597 : _Py_DECREF_NO_DEALLOC(cond);
4147 : 7630597 : DISPATCH();
4148 : : }
4149 [ + + ]: 30225227 : if (Py_IsFalse(cond)) {
4150 : 21298004 : _Py_DECREF_NO_DEALLOC(cond);
4151 : 21298004 : JUMPBY(-oparg);
4152 [ + + ]: 21298004 : CHECK_EVAL_BREAKER();
4153 : 21297932 : DISPATCH();
4154 : : }
4155 : 8927223 : int err = PyObject_IsTrue(cond);
4156 [ + + ]: 8927223 : Py_DECREF(cond);
4157 [ + + ]: 8927223 : if (err > 0)
4158 : : ;
4159 [ + + ]: 2742401 : else if (err == 0) {
4160 : 2742400 : JUMPBY(-oparg);
4161 [ - + ]: 2742400 : CHECK_EVAL_BREAKER();
4162 : : }
4163 : : else
4164 : 1 : goto error;
4165 : 8927222 : DISPATCH();
4166 : : }
4167 : :
4168 : 226719259 : TARGET(POP_JUMP_FORWARD_IF_FALSE) {
4169 : 226719259 : PREDICTED(POP_JUMP_FORWARD_IF_FALSE);
4170 : 226719259 : PyObject *cond = POP();
4171 [ + + ]: 226719259 : if (Py_IsTrue(cond)) {
4172 : 63372423 : _Py_DECREF_NO_DEALLOC(cond);
4173 : : }
4174 [ + + ]: 163346836 : else if (Py_IsFalse(cond)) {
4175 : 114052696 : _Py_DECREF_NO_DEALLOC(cond);
4176 : 114052696 : JUMPBY(oparg);
4177 : : }
4178 : : else {
4179 : 49294140 : int err = PyObject_IsTrue(cond);
4180 [ + + ]: 49294140 : Py_DECREF(cond);
4181 [ + + ]: 49294140 : if (err > 0)
4182 : : ;
4183 [ + + ]: 23143430 : else if (err == 0) {
4184 : 23143425 : JUMPBY(oparg);
4185 : : }
4186 : : else
4187 : 5 : goto error;
4188 : : }
4189 : 226719254 : DISPATCH();
4190 : : }
4191 : :
4192 : 10916958 : TARGET(POP_JUMP_BACKWARD_IF_TRUE) {
4193 : 10916958 : PyObject *cond = POP();
4194 [ + + ]: 10916958 : if (Py_IsFalse(cond)) {
4195 : 1567378 : _Py_DECREF_NO_DEALLOC(cond);
4196 : 1567378 : DISPATCH();
4197 : : }
4198 [ + + ]: 9349580 : if (Py_IsTrue(cond)) {
4199 : 8137835 : _Py_DECREF_NO_DEALLOC(cond);
4200 : 8137835 : JUMPBY(-oparg);
4201 [ + + ]: 8137835 : CHECK_EVAL_BREAKER();
4202 : 8137826 : DISPATCH();
4203 : : }
4204 : 1211745 : int err = PyObject_IsTrue(cond);
4205 [ + + ]: 1211745 : Py_DECREF(cond);
4206 [ + + ]: 1211745 : if (err > 0) {
4207 : 938697 : JUMPBY(-oparg);
4208 [ + + ]: 938697 : CHECK_EVAL_BREAKER();
4209 : : }
4210 [ - + ]: 273048 : else if (err == 0)
4211 : : ;
4212 : : else
4213 : 0 : goto error;
4214 : 1211606 : DISPATCH();
4215 : : }
4216 : :
4217 : 87481045 : TARGET(POP_JUMP_FORWARD_IF_TRUE) {
4218 : 87481045 : PyObject *cond = POP();
4219 [ + + ]: 87481045 : if (Py_IsFalse(cond)) {
4220 : 35393037 : _Py_DECREF_NO_DEALLOC(cond);
4221 : : }
4222 [ + + ]: 52088008 : else if (Py_IsTrue(cond)) {
4223 : 24307462 : _Py_DECREF_NO_DEALLOC(cond);
4224 : 24307462 : JUMPBY(oparg);
4225 : : }
4226 : : else {
4227 : 27780546 : int err = PyObject_IsTrue(cond);
4228 [ + + ]: 27780546 : Py_DECREF(cond);
4229 [ + + ]: 27780546 : if (err > 0) {
4230 : 23452513 : JUMPBY(oparg);
4231 : : }
4232 [ + + ]: 4328033 : else if (err == 0)
4233 : : ;
4234 : : else
4235 : 1 : goto error;
4236 : : }
4237 : 87481044 : DISPATCH();
4238 : : }
4239 : :
4240 : 502176 : TARGET(POP_JUMP_BACKWARD_IF_NOT_NONE) {
4241 : 502176 : PyObject *value = POP();
4242 [ + + ]: 502176 : if (!Py_IsNone(value)) {
4243 [ + + ]: 280969 : Py_DECREF(value);
4244 : 280969 : JUMPBY(-oparg);
4245 [ + + ]: 280969 : CHECK_EVAL_BREAKER();
4246 : 280968 : DISPATCH();
4247 : : }
4248 : 221207 : _Py_DECREF_NO_DEALLOC(value);
4249 : 221207 : DISPATCH();
4250 : : }
4251 : :
4252 : 38259715 : TARGET(POP_JUMP_FORWARD_IF_NOT_NONE) {
4253 : 38259715 : PyObject *value = POP();
4254 [ + + ]: 38259715 : if (!Py_IsNone(value)) {
4255 : 23938705 : JUMPBY(oparg);
4256 : : }
4257 [ + + ]: 38259715 : Py_DECREF(value);
4258 : 38259715 : DISPATCH();
4259 : : }
4260 : :
4261 : 2339987 : TARGET(POP_JUMP_BACKWARD_IF_NONE) {
4262 : 2339987 : PyObject *value = POP();
4263 [ + + ]: 2339987 : if (Py_IsNone(value)) {
4264 : 979702 : _Py_DECREF_NO_DEALLOC(value);
4265 : 979702 : JUMPBY(-oparg);
4266 [ + + ]: 979702 : CHECK_EVAL_BREAKER();
4267 : : }
4268 : : else {
4269 [ + + ]: 1360285 : Py_DECREF(value);
4270 : : }
4271 : 2339960 : DISPATCH();
4272 : : }
4273 : :
4274 : 38123200 : TARGET(POP_JUMP_FORWARD_IF_NONE) {
4275 : 38123200 : PyObject *value = POP();
4276 [ + + ]: 38123200 : if (Py_IsNone(value)) {
4277 : 18503365 : _Py_DECREF_NO_DEALLOC(value);
4278 : 18503365 : JUMPBY(oparg);
4279 : : }
4280 : : else {
4281 [ + + ]: 19619835 : Py_DECREF(value);
4282 : : }
4283 : 38123200 : DISPATCH();
4284 : : }
4285 : :
4286 : 11109912 : TARGET(JUMP_IF_FALSE_OR_POP) {
4287 : 11109912 : PyObject *cond = TOP();
4288 : : int err;
4289 [ + + ]: 11109912 : if (Py_IsTrue(cond)) {
4290 : 8207536 : STACK_SHRINK(1);
4291 : 8207536 : _Py_DECREF_NO_DEALLOC(cond);
4292 : 8207536 : DISPATCH();
4293 : : }
4294 [ + + ]: 2902376 : if (Py_IsFalse(cond)) {
4295 : 2686159 : JUMPBY(oparg);
4296 : 2686159 : DISPATCH();
4297 : : }
4298 : 216217 : err = PyObject_IsTrue(cond);
4299 [ + + ]: 216217 : if (err > 0) {
4300 : 16413 : STACK_SHRINK(1);
4301 [ + + ]: 16413 : Py_DECREF(cond);
4302 : : }
4303 [ + - ]: 199804 : else if (err == 0)
4304 : 199804 : JUMPBY(oparg);
4305 : : else
4306 : 0 : goto error;
4307 : 216217 : DISPATCH();
4308 : : }
4309 : :
4310 : 5419033 : TARGET(JUMP_IF_TRUE_OR_POP) {
4311 : 5419033 : PyObject *cond = TOP();
4312 : : int err;
4313 [ + + ]: 5419033 : if (Py_IsFalse(cond)) {
4314 : 2456437 : STACK_SHRINK(1);
4315 : 2456437 : _Py_DECREF_NO_DEALLOC(cond);
4316 : 2456437 : DISPATCH();
4317 : : }
4318 [ + + ]: 2962596 : if (Py_IsTrue(cond)) {
4319 : 180061 : JUMPBY(oparg);
4320 : 180061 : DISPATCH();
4321 : : }
4322 : 2782535 : err = PyObject_IsTrue(cond);
4323 [ + + ]: 2782535 : if (err > 0) {
4324 : 1807847 : JUMPBY(oparg);
4325 : : }
4326 [ + - ]: 974688 : else if (err == 0) {
4327 : 974688 : STACK_SHRINK(1);
4328 [ + + ]: 974688 : Py_DECREF(cond);
4329 : : }
4330 : : else
4331 : 0 : goto error;
4332 : 2782535 : DISPATCH();
4333 : : }
4334 : :
4335 : 5954450 : TARGET(JUMP_BACKWARD_NO_INTERRUPT) {
4336 : : /* This bytecode is used in the `yield from` or `await` loop.
4337 : : * If there is an interrupt, we want it handled in the innermost
4338 : : * generator or coroutine, so we deliberately do not check it here.
4339 : : * (see bpo-30039).
4340 : : */
4341 : 5954450 : JUMPBY(-oparg);
4342 : 5954450 : DISPATCH();
4343 : : }
4344 : :
4345 : 131951703 : TARGET(JUMP_BACKWARD_QUICK) {
4346 : 133076907 : PREDICTED(JUMP_BACKWARD_QUICK);
4347 : : assert(oparg < INSTR_OFFSET());
4348 : 133076907 : JUMPBY(-oparg);
4349 [ + + ]: 133076907 : CHECK_EVAL_BREAKER();
4350 : 133076252 : DISPATCH();
4351 : : }
4352 : :
4353 : 621 : TARGET(GET_LEN) {
4354 : : // PUSH(len(TOS))
4355 : 621 : Py_ssize_t len_i = PyObject_Length(TOP());
4356 [ - + ]: 621 : if (len_i < 0) {
4357 : 0 : goto error;
4358 : : }
4359 : 621 : PyObject *len_o = PyLong_FromSsize_t(len_i);
4360 [ - + ]: 621 : if (len_o == NULL) {
4361 : 0 : goto error;
4362 : : }
4363 : 621 : PUSH(len_o);
4364 : 621 : DISPATCH();
4365 : : }
4366 : :
4367 : 12841 : TARGET(MATCH_CLASS) {
4368 : : // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or
4369 : : // None on failure.
4370 : 12841 : PyObject *names = POP();
4371 : 12841 : PyObject *type = POP();
4372 : 12841 : PyObject *subject = TOP();
4373 : : assert(PyTuple_CheckExact(names));
4374 : 12841 : PyObject *attrs = match_class(tstate, subject, type, oparg, names);
4375 [ - + ]: 12841 : Py_DECREF(names);
4376 [ - + ]: 12841 : Py_DECREF(type);
4377 [ + + ]: 12841 : if (attrs) {
4378 : : // Success!
4379 : : assert(PyTuple_CheckExact(attrs));
4380 : 5550 : SET_TOP(attrs);
4381 : : }
4382 [ + + ]: 7291 : else if (_PyErr_Occurred(tstate)) {
4383 : : // Error!
4384 : 8 : goto error;
4385 : : }
4386 : : else {
4387 : : // Failure!
4388 : 7283 : Py_INCREF(Py_None);
4389 : 7283 : SET_TOP(Py_None);
4390 : : }
4391 [ + + ]: 12833 : Py_DECREF(subject);
4392 : 12833 : DISPATCH();
4393 : : }
4394 : :
4395 : 92 : TARGET(MATCH_MAPPING) {
4396 : 92 : PyObject *subject = TOP();
4397 : 92 : int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING;
4398 [ + + ]: 92 : PyObject *res = match ? Py_True : Py_False;
4399 : 92 : Py_INCREF(res);
4400 : 92 : PUSH(res);
4401 : : PREDICT(POP_JUMP_FORWARD_IF_FALSE);
4402 : : PREDICT(POP_JUMP_BACKWARD_IF_FALSE);
4403 : 92 : DISPATCH();
4404 : : }
4405 : :
4406 : 734 : TARGET(MATCH_SEQUENCE) {
4407 : 734 : PyObject *subject = TOP();
4408 : 734 : int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE;
4409 [ + + ]: 734 : PyObject *res = match ? Py_True : Py_False;
4410 : 734 : Py_INCREF(res);
4411 : 734 : PUSH(res);
4412 : : PREDICT(POP_JUMP_FORWARD_IF_FALSE);
4413 : : PREDICT(POP_JUMP_BACKWARD_IF_FALSE);
4414 : 734 : DISPATCH();
4415 : : }
4416 : :
4417 : 47 : TARGET(MATCH_KEYS) {
4418 : : // On successful match, PUSH(values). Otherwise, PUSH(None).
4419 : 47 : PyObject *keys = TOP();
4420 : 47 : PyObject *subject = SECOND();
4421 : 47 : PyObject *values_or_none = match_keys(tstate, subject, keys);
4422 [ + + ]: 47 : if (values_or_none == NULL) {
4423 : 1 : goto error;
4424 : : }
4425 : 46 : PUSH(values_or_none);
4426 : 46 : DISPATCH();
4427 : : }
4428 : :
4429 : 42385154 : TARGET(GET_ITER) {
4430 : : /* before: [obj]; after [getiter(obj)] */
4431 : 42385154 : PyObject *iterable = TOP();
4432 : 42385154 : PyObject *iter = PyObject_GetIter(iterable);
4433 [ + + ]: 42385154 : Py_DECREF(iterable);
4434 : 42385154 : SET_TOP(iter);
4435 [ + + ]: 42385154 : if (iter == NULL)
4436 : 86 : goto error;
4437 : 42385068 : DISPATCH();
4438 : : }
4439 : :
4440 : 770258 : TARGET(GET_YIELD_FROM_ITER) {
4441 : : /* before: [obj]; after [getiter(obj)] */
4442 : 770258 : PyObject *iterable = TOP();
4443 : : PyObject *iter;
4444 [ + + ]: 770258 : if (PyCoro_CheckExact(iterable)) {
4445 : : /* `iterable` is a coroutine */
4446 [ + + ]: 2 : if (!(frame->f_code->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) {
4447 : : /* and it is used in a 'yield from' expression of a
4448 : : regular generator. */
4449 [ - + ]: 1 : Py_DECREF(iterable);
4450 : 1 : SET_TOP(NULL);
4451 : 1 : _PyErr_SetString(tstate, PyExc_TypeError,
4452 : : "cannot 'yield from' a coroutine object "
4453 : : "in a non-coroutine generator");
4454 : 1 : goto error;
4455 : : }
4456 : : }
4457 [ + + ]: 770256 : else if (!PyGen_CheckExact(iterable)) {
4458 : : /* `iterable` is not a generator. */
4459 : 14017 : iter = PyObject_GetIter(iterable);
4460 [ + + ]: 14017 : Py_DECREF(iterable);
4461 : 14017 : SET_TOP(iter);
4462 [ - + ]: 14017 : if (iter == NULL)
4463 : 0 : goto error;
4464 : : }
4465 : : PREDICT(LOAD_CONST);
4466 : 770257 : DISPATCH();
4467 : : }
4468 : :
4469 : 5137335 : TARGET(FOR_ITER) {
4470 : 105891374 : PREDICTED(FOR_ITER);
4471 : : /* before: [iter]; after: [iter, iter()] *or* [] */
4472 : 105891374 : PyObject *iter = TOP();
4473 : 105891374 : PyObject *next = (*Py_TYPE(iter)->tp_iternext)(iter);
4474 [ + + ]: 105891374 : if (next != NULL) {
4475 : 76122070 : PUSH(next);
4476 : 76122070 : JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER);
4477 : 76122070 : DISPATCH();
4478 : : }
4479 [ + + ]: 29769304 : if (_PyErr_Occurred(tstate)) {
4480 [ + + ]: 6330 : if (!_PyErr_ExceptionMatches(tstate, PyExc_StopIteration)) {
4481 : 1127 : goto error;
4482 : : }
4483 [ + + ]: 5203 : else if (tstate->c_tracefunc != NULL) {
4484 : 5 : call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj, tstate, frame);
4485 : : }
4486 : 5203 : _PyErr_Clear(tstate);
4487 : : }
4488 : 29762974 : iterator_exhausted_no_error:
4489 : : /* iterator ended normally */
4490 : : assert(!_PyErr_Occurred(tstate));
4491 [ + + ]: 38734289 : Py_DECREF(POP());
4492 : 38734289 : JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + oparg);
4493 : 38734289 : DISPATCH();
4494 : : }
4495 : :
4496 : 101551565 : TARGET(FOR_ITER_ADAPTIVE) {
4497 : : assert(cframe.use_tracing == 0);
4498 : 101551565 : _PyForIterCache *cache = (_PyForIterCache *)next_instr;
4499 [ + + ]: 101551565 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
4500 : 797526 : next_instr--;
4501 : 797526 : _Py_Specialize_ForIter(TOP(), next_instr);
4502 : 797526 : NOTRACE_DISPATCH_SAME_OPARG();
4503 : : }
4504 : : else {
4505 : : STAT_INC(FOR_ITER, deferred);
4506 : 100754039 : DECREMENT_ADAPTIVE_COUNTER(cache);
4507 : 100754039 : JUMP_TO_INSTRUCTION(FOR_ITER);
4508 : : }
4509 : : }
4510 : :
4511 : 44207594 : TARGET(FOR_ITER_LIST) {
4512 : : assert(cframe.use_tracing == 0);
4513 : 44207594 : _PyListIterObject *it = (_PyListIterObject *)TOP();
4514 [ + + ]: 44207594 : DEOPT_IF(Py_TYPE(it) != &PyListIter_Type, FOR_ITER);
4515 : : STAT_INC(FOR_ITER, hit);
4516 : 43871486 : PyListObject *seq = it->it_seq;
4517 [ + + ]: 43871486 : if (seq == NULL) {
4518 : 1589 : goto iterator_exhausted_no_error;
4519 : : }
4520 [ + + ]: 43869897 : if (it->it_index < PyList_GET_SIZE(seq)) {
4521 : 35842541 : PyObject *next = PyList_GET_ITEM(seq, it->it_index++);
4522 : 35842541 : Py_INCREF(next);
4523 : 35842541 : PUSH(next);
4524 : 35842541 : JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER);
4525 : 35842541 : NOTRACE_DISPATCH();
4526 : : }
4527 : 8027356 : it->it_seq = NULL;
4528 [ + + ]: 8027356 : Py_DECREF(seq);
4529 : 8027356 : goto iterator_exhausted_no_error;
4530 : : }
4531 : :
4532 : 46718175 : TARGET(FOR_ITER_RANGE) {
4533 : : assert(cframe.use_tracing == 0);
4534 : 46718175 : _PyRangeIterObject *r = (_PyRangeIterObject *)TOP();
4535 [ + + ]: 46718175 : DEOPT_IF(Py_TYPE(r) != &PyRangeIter_Type, FOR_ITER);
4536 : : STAT_INC(FOR_ITER, hit);
4537 : 46712284 : _Py_CODEUNIT next = next_instr[INLINE_CACHE_ENTRIES_FOR_ITER];
4538 : : assert(_PyOpcode_Deopt[_Py_OPCODE(next)] == STORE_FAST);
4539 [ + + ]: 46712284 : if (r->index >= r->len) {
4540 : 937167 : goto iterator_exhausted_no_error;
4541 : : }
4542 : 45775117 : long value = (long)(r->start +
4543 : 45775117 : (unsigned long)(r->index++) * r->step);
4544 [ - + ]: 45775117 : if (_PyLong_AssignValue(&GETLOCAL(_Py_OPARG(next)), value) < 0) {
4545 : 0 : goto error;
4546 : : }
4547 : : // The STORE_FAST is already done.
4548 : 45775117 : JUMPBY(INLINE_CACHE_ENTRIES_FOR_ITER + 1);
4549 : 45775117 : NOTRACE_DISPATCH();
4550 : : }
4551 : :
4552 : 378 : TARGET(BEFORE_ASYNC_WITH) {
4553 : 378 : PyObject *mgr = TOP();
4554 : : PyObject *res;
4555 : 378 : PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__aenter__));
4556 [ + + ]: 378 : if (enter == NULL) {
4557 [ + - ]: 2 : if (!_PyErr_Occurred(tstate)) {
4558 : 2 : _PyErr_Format(tstate, PyExc_TypeError,
4559 : : "'%.200s' object does not support the "
4560 : : "asynchronous context manager protocol",
4561 : 2 : Py_TYPE(mgr)->tp_name);
4562 : : }
4563 : 2 : goto error;
4564 : : }
4565 : 376 : PyObject *exit = _PyObject_LookupSpecial(mgr, &_Py_ID(__aexit__));
4566 [ + + ]: 376 : if (exit == NULL) {
4567 [ + - ]: 1 : if (!_PyErr_Occurred(tstate)) {
4568 : 1 : _PyErr_Format(tstate, PyExc_TypeError,
4569 : : "'%.200s' object does not support the "
4570 : : "asynchronous context manager protocol "
4571 : : "(missed __aexit__ method)",
4572 : 1 : Py_TYPE(mgr)->tp_name);
4573 : : }
4574 [ + - ]: 1 : Py_DECREF(enter);
4575 : 1 : goto error;
4576 : : }
4577 : 375 : SET_TOP(exit);
4578 [ - + ]: 375 : Py_DECREF(mgr);
4579 : 375 : res = _PyObject_CallNoArgs(enter);
4580 [ + + ]: 375 : Py_DECREF(enter);
4581 [ - + ]: 375 : if (res == NULL)
4582 : 0 : goto error;
4583 : 375 : PUSH(res);
4584 : : PREDICT(GET_AWAITABLE);
4585 : 375 : DISPATCH();
4586 : : }
4587 : :
4588 : 4384391 : TARGET(BEFORE_WITH) {
4589 : 4384391 : PyObject *mgr = TOP();
4590 : : PyObject *res;
4591 : 4384391 : PyObject *enter = _PyObject_LookupSpecial(mgr, &_Py_ID(__enter__));
4592 [ + + ]: 4384391 : if (enter == NULL) {
4593 [ + + ]: 4 : if (!_PyErr_Occurred(tstate)) {
4594 : 3 : _PyErr_Format(tstate, PyExc_TypeError,
4595 : : "'%.200s' object does not support the "
4596 : : "context manager protocol",
4597 : 3 : Py_TYPE(mgr)->tp_name);
4598 : : }
4599 : 4 : goto error;
4600 : : }
4601 : 4384387 : PyObject *exit = _PyObject_LookupSpecial(mgr, &_Py_ID(__exit__));
4602 [ + + ]: 4384387 : if (exit == NULL) {
4603 [ + + ]: 3 : if (!_PyErr_Occurred(tstate)) {
4604 : 2 : _PyErr_Format(tstate, PyExc_TypeError,
4605 : : "'%.200s' object does not support the "
4606 : : "context manager protocol "
4607 : : "(missed __exit__ method)",
4608 : 2 : Py_TYPE(mgr)->tp_name);
4609 : : }
4610 [ + - ]: 3 : Py_DECREF(enter);
4611 : 3 : goto error;
4612 : : }
4613 : 4384384 : SET_TOP(exit);
4614 [ - + ]: 4384384 : Py_DECREF(mgr);
4615 : 4384384 : res = _PyObject_CallNoArgs(enter);
4616 [ + + ]: 4384384 : Py_DECREF(enter);
4617 [ + + ]: 4384384 : if (res == NULL) {
4618 : 75 : goto error;
4619 : : }
4620 : 4384309 : PUSH(res);
4621 : 4384309 : DISPATCH();
4622 : : }
4623 : :
4624 : 218376 : TARGET(WITH_EXCEPT_START) {
4625 : : /* At the top of the stack are 4 values:
4626 : : - TOP = exc_info()
4627 : : - SECOND = previous exception
4628 : : - THIRD: lasti of exception in exc_info()
4629 : : - FOURTH: the context.__exit__ bound method
4630 : : We call FOURTH(type(TOP), TOP, GetTraceback(TOP)).
4631 : : Then we push the __exit__ return value.
4632 : : */
4633 : : PyObject *exit_func;
4634 : : PyObject *exc, *val, *tb, *res;
4635 : :
4636 : 218376 : val = TOP();
4637 : : assert(val && PyExceptionInstance_Check(val));
4638 : 218376 : exc = PyExceptionInstance_Class(val);
4639 : 218376 : tb = PyException_GetTraceback(val);
4640 [ + - - + ]: 218376 : Py_XDECREF(tb);
4641 : : assert(PyLong_Check(PEEK(3)));
4642 : 218376 : exit_func = PEEK(4);
4643 : 218376 : PyObject *stack[4] = {NULL, exc, val, tb};
4644 : 218376 : res = PyObject_Vectorcall(exit_func, stack + 1,
4645 : : 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
4646 [ + + ]: 218376 : if (res == NULL)
4647 : 39 : goto error;
4648 : :
4649 : 218337 : PUSH(res);
4650 : 218337 : DISPATCH();
4651 : : }
4652 : :
4653 : 3900609 : TARGET(PUSH_EXC_INFO) {
4654 : 3900609 : PyObject *value = TOP();
4655 : :
4656 : 3900609 : _PyErr_StackItem *exc_info = tstate->exc_info;
4657 [ + + ]: 3900609 : if (exc_info->exc_value != NULL) {
4658 : 3561183 : SET_TOP(exc_info->exc_value);
4659 : : }
4660 : : else {
4661 : 339426 : Py_INCREF(Py_None);
4662 : 339426 : SET_TOP(Py_None);
4663 : : }
4664 : :
4665 : 3900609 : Py_INCREF(value);
4666 : 3900609 : PUSH(value);
4667 : : assert(PyExceptionInstance_Check(value));
4668 : 3900609 : exc_info->exc_value = value;
4669 : :
4670 : 3900609 : DISPATCH();
4671 : : }
4672 : :
4673 : 73549186 : TARGET(LOAD_ATTR_METHOD_WITH_VALUES) {
4674 : : /* Cached method object */
4675 : : assert(cframe.use_tracing == 0);
4676 : 73549186 : PyObject *self = TOP();
4677 : 73549186 : PyTypeObject *self_cls = Py_TYPE(self);
4678 : 73549186 : _PyLoadMethodCache *cache = (_PyLoadMethodCache *)next_instr;
4679 : 73549186 : uint32_t type_version = read_u32(cache->type_version);
4680 : : assert(type_version != 0);
4681 [ + + ]: 73549186 : DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
4682 : : assert(self_cls->tp_flags & Py_TPFLAGS_MANAGED_DICT);
4683 : 68996071 : PyDictObject *dict = *(PyDictObject**)_PyObject_ManagedDictPointer(self);
4684 [ + + ]: 68996071 : DEOPT_IF(dict != NULL, LOAD_ATTR);
4685 : 68975948 : PyHeapTypeObject *self_heap_type = (PyHeapTypeObject *)self_cls;
4686 [ + + ]: 68975948 : DEOPT_IF(self_heap_type->ht_cached_keys->dk_version !=
4687 : : read_u32(cache->keys_version), LOAD_ATTR);
4688 : : STAT_INC(LOAD_ATTR, hit);
4689 : 68846003 : PyObject *res = read_obj(cache->descr);
4690 : : assert(res != NULL);
4691 : : assert(_PyType_HasFeature(Py_TYPE(res), Py_TPFLAGS_METHOD_DESCRIPTOR));
4692 : 68846003 : Py_INCREF(res);
4693 : 68846003 : SET_TOP(res);
4694 : 68846003 : PUSH(self);
4695 : 68846003 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
4696 : 68846003 : NOTRACE_DISPATCH();
4697 : : }
4698 : :
4699 : 943872 : TARGET(LOAD_ATTR_METHOD_WITH_DICT) {
4700 : : /* Can be either a managed dict, or a tp_dictoffset offset.*/
4701 : : assert(cframe.use_tracing == 0);
4702 : 943872 : PyObject *self = TOP();
4703 : 943872 : PyTypeObject *self_cls = Py_TYPE(self);
4704 : 943872 : _PyLoadMethodCache *cache = (_PyLoadMethodCache *)next_instr;
4705 : :
4706 [ + + ]: 943872 : DEOPT_IF(self_cls->tp_version_tag != read_u32(cache->type_version),
4707 : : LOAD_ATTR);
4708 : : /* Treat index as a signed 16 bit value */
4709 : 932828 : Py_ssize_t dictoffset = self_cls->tp_dictoffset;
4710 : : assert(dictoffset > 0);
4711 : 932828 : PyDictObject **dictptr = (PyDictObject**)(((char *)self)+dictoffset);
4712 : 932828 : PyDictObject *dict = *dictptr;
4713 [ + + ]: 932828 : DEOPT_IF(dict == NULL, LOAD_ATTR);
4714 [ + + ]: 932621 : DEOPT_IF(dict->ma_keys->dk_version != read_u32(cache->keys_version),
4715 : : LOAD_ATTR);
4716 : : STAT_INC(LOAD_ATTR, hit);
4717 : 816265 : PyObject *res = read_obj(cache->descr);
4718 : : assert(res != NULL);
4719 : : assert(_PyType_HasFeature(Py_TYPE(res), Py_TPFLAGS_METHOD_DESCRIPTOR));
4720 : 816265 : Py_INCREF(res);
4721 : 816265 : SET_TOP(res);
4722 : 816265 : PUSH(self);
4723 : 816265 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
4724 : 816265 : NOTRACE_DISPATCH();
4725 : : }
4726 : :
4727 : 170916147 : TARGET(LOAD_ATTR_METHOD_NO_DICT) {
4728 : : assert(cframe.use_tracing == 0);
4729 : 170916147 : PyObject *self = TOP();
4730 : 170916147 : PyTypeObject *self_cls = Py_TYPE(self);
4731 : 170916147 : _PyLoadMethodCache *cache = (_PyLoadMethodCache *)next_instr;
4732 : 170916147 : uint32_t type_version = read_u32(cache->type_version);
4733 [ + + ]: 170916147 : DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
4734 : : assert(self_cls->tp_dictoffset == 0);
4735 : : STAT_INC(LOAD_ATTR, hit);
4736 : 170787473 : PyObject *res = read_obj(cache->descr);
4737 : : assert(res != NULL);
4738 : : assert(_PyType_HasFeature(Py_TYPE(res), Py_TPFLAGS_METHOD_DESCRIPTOR));
4739 : 170787473 : Py_INCREF(res);
4740 : 170787473 : SET_TOP(res);
4741 : 170787473 : PUSH(self);
4742 : 170787473 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
4743 : 170787473 : NOTRACE_DISPATCH();
4744 : : }
4745 : :
4746 : 12975728 : TARGET(LOAD_ATTR_METHOD_LAZY_DICT) {
4747 : : assert(cframe.use_tracing == 0);
4748 : 12975728 : PyObject *self = TOP();
4749 : 12975728 : PyTypeObject *self_cls = Py_TYPE(self);
4750 : 12975728 : _PyLoadMethodCache *cache = (_PyLoadMethodCache *)next_instr;
4751 : 12975728 : uint32_t type_version = read_u32(cache->type_version);
4752 [ + + ]: 12975728 : DEOPT_IF(self_cls->tp_version_tag != type_version, LOAD_ATTR);
4753 : 12915774 : Py_ssize_t dictoffset = self_cls->tp_dictoffset;
4754 : : assert(dictoffset > 0);
4755 : 12915774 : PyObject *dict = *(PyObject **)((char *)self + dictoffset);
4756 : : /* This object has a __dict__, just not yet created */
4757 [ + + ]: 12915774 : DEOPT_IF(dict != NULL, LOAD_ATTR);
4758 : : STAT_INC(LOAD_ATTR, hit);
4759 : 12915596 : PyObject *res = read_obj(cache->descr);
4760 : : assert(res != NULL);
4761 : : assert(_PyType_HasFeature(Py_TYPE(res), Py_TPFLAGS_METHOD_DESCRIPTOR));
4762 : 12915596 : Py_INCREF(res);
4763 : 12915596 : SET_TOP(res);
4764 : 12915596 : PUSH(self);
4765 : 12915596 : JUMPBY(INLINE_CACHE_ENTRIES_LOAD_ATTR);
4766 : 12915596 : NOTRACE_DISPATCH();
4767 : : }
4768 : :
4769 : 21038995 : TARGET(CALL_BOUND_METHOD_EXACT_ARGS) {
4770 [ + + ]: 21038995 : DEOPT_IF(is_method(stack_pointer, oparg), CALL);
4771 : 19820210 : PyObject *function = PEEK(oparg + 1);
4772 [ + + ]: 19820210 : DEOPT_IF(Py_TYPE(function) != &PyMethod_Type, CALL);
4773 : : STAT_INC(CALL, hit);
4774 : 19806987 : PyObject *meth = ((PyMethodObject *)function)->im_func;
4775 : 19806987 : PyObject *self = ((PyMethodObject *)function)->im_self;
4776 : 19806987 : Py_INCREF(meth);
4777 : 19806987 : Py_INCREF(self);
4778 : 19806987 : PEEK(oparg + 1) = self;
4779 : 19806987 : PEEK(oparg + 2) = meth;
4780 [ + + ]: 19806987 : Py_DECREF(function);
4781 : 19806987 : goto call_exact_args;
4782 : : }
4783 : :
4784 : 16837805 : TARGET(KW_NAMES) {
4785 : : assert(call_shape.kwnames == NULL);
4786 : : assert(oparg < PyTuple_GET_SIZE(consts));
4787 : 16837805 : call_shape.kwnames = GETITEM(consts, oparg);
4788 : 16837805 : DISPATCH();
4789 : : }
4790 : :
4791 : 41620080 : TARGET(CALL) {
4792 : : int total_args, is_meth;
4793 : 190577403 : call_function:
4794 : 190577403 : is_meth = is_method(stack_pointer, oparg);
4795 : 190577403 : PyObject *function = PEEK(oparg + 1);
4796 [ + + + + ]: 190577403 : if (!is_meth && Py_TYPE(function) == &PyMethod_Type) {
4797 : 12109403 : PyObject *meth = ((PyMethodObject *)function)->im_func;
4798 : 12109403 : PyObject *self = ((PyMethodObject *)function)->im_self;
4799 : 12109403 : Py_INCREF(meth);
4800 : 12109403 : Py_INCREF(self);
4801 : 12109403 : PEEK(oparg+1) = self;
4802 : 12109403 : PEEK(oparg+2) = meth;
4803 [ + + ]: 12109403 : Py_DECREF(function);
4804 : 12109403 : is_meth = 1;
4805 : : }
4806 : 190577403 : total_args = oparg + is_meth;
4807 : 190577403 : function = PEEK(total_args + 1);
4808 [ + + ]: 190577403 : int positional_args = total_args - KWNAMES_LEN();
4809 : : // Check if the call can be inlined or not
4810 [ + + + + ]: 190577403 : if (Py_TYPE(function) == &PyFunction_Type && tstate->interp->eval_frame == NULL) {
4811 : 48620567 : int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(function))->co_flags;
4812 [ + + ]: 48620567 : PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(function));
4813 : 48620567 : STACK_SHRINK(total_args);
4814 : 48620567 : _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
4815 : : tstate, (PyFunctionObject *)function, locals,
4816 : : stack_pointer, positional_args, call_shape.kwnames
4817 : : );
4818 : 48620567 : call_shape.kwnames = NULL;
4819 : 48620567 : STACK_SHRINK(2-is_meth);
4820 : : // The frame has stolen all the arguments from the stack,
4821 : : // so there is no need to clean them up.
4822 [ + + ]: 48620567 : if (new_frame == NULL) {
4823 : 1312 : goto error;
4824 : : }
4825 : 48619255 : _PyFrame_SetStackPointer(frame, stack_pointer);
4826 : 48619255 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
4827 : 48619255 : frame->prev_instr = next_instr - 1;
4828 : 48619255 : new_frame->previous = frame;
4829 : 48619255 : cframe.current_frame = frame = new_frame;
4830 : : CALL_STAT_INC(inlined_py_calls);
4831 : 48619255 : goto start_frame;
4832 : : }
4833 : : /* Callable is not a normal Python function */
4834 : : PyObject *res;
4835 [ + + ]: 141956836 : if (cframe.use_tracing) {
4836 : 1992766 : res = trace_call_function(
4837 : 1992766 : tstate, function, stack_pointer-total_args,
4838 : : positional_args, call_shape.kwnames);
4839 : : }
4840 : : else {
4841 : 139964070 : res = PyObject_Vectorcall(
4842 : 139964070 : function, stack_pointer-total_args,
4843 : : positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
4844 : : call_shape.kwnames);
4845 : : }
4846 : 141956760 : call_shape.kwnames = NULL;
4847 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
4848 [ + + ]: 141956760 : Py_DECREF(function);
4849 : : /* Clear the stack */
4850 : 141956760 : STACK_SHRINK(total_args);
4851 [ + + ]: 383736491 : for (int i = 0; i < total_args; i++) {
4852 [ + + ]: 241779731 : Py_DECREF(stack_pointer[i]);
4853 : : }
4854 : 141956760 : STACK_SHRINK(2-is_meth);
4855 : 141956760 : PUSH(res);
4856 [ + + ]: 141956760 : if (res == NULL) {
4857 : 258786 : goto error;
4858 : : }
4859 : 141697974 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
4860 [ + + ]: 141697974 : CHECK_EVAL_BREAKER();
4861 : 141677541 : DISPATCH();
4862 : : }
4863 : :
4864 : 152347941 : TARGET(CALL_ADAPTIVE) {
4865 : 152347941 : _PyCallCache *cache = (_PyCallCache *)next_instr;
4866 [ + + ]: 152347941 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
4867 : 3390618 : next_instr--;
4868 : 3390618 : int is_meth = is_method(stack_pointer, oparg);
4869 : 3390618 : int nargs = oparg + is_meth;
4870 : 3390618 : PyObject *callable = PEEK(nargs + 1);
4871 : 3390618 : int err = _Py_Specialize_Call(callable, next_instr, nargs,
4872 : : call_shape.kwnames);
4873 [ - + ]: 3390618 : if (err < 0) {
4874 : 0 : goto error;
4875 : : }
4876 : 3390618 : NOTRACE_DISPATCH_SAME_OPARG();
4877 : : }
4878 : : else {
4879 : : STAT_INC(CALL, deferred);
4880 : 148957323 : DECREMENT_ADAPTIVE_COUNTER(cache);
4881 : 148957323 : goto call_function;
4882 : : }
4883 : : }
4884 : :
4885 : 113539329 : TARGET(CALL_PY_EXACT_ARGS) {
4886 : 133346316 : call_exact_args:
4887 : : assert(call_shape.kwnames == NULL);
4888 [ + + ]: 133346316 : DEOPT_IF(tstate->interp->eval_frame, CALL);
4889 : 133346263 : _PyCallCache *cache = (_PyCallCache *)next_instr;
4890 : 133346263 : int is_meth = is_method(stack_pointer, oparg);
4891 : 133346263 : int argcount = oparg + is_meth;
4892 : 133346263 : PyObject *callable = PEEK(argcount + 1);
4893 [ + + ]: 133346263 : DEOPT_IF(!PyFunction_Check(callable), CALL);
4894 : 133296330 : PyFunctionObject *func = (PyFunctionObject *)callable;
4895 [ + + ]: 133296330 : DEOPT_IF(func->func_version != read_u32(cache->func_version), CALL);
4896 : 122742764 : PyCodeObject *code = (PyCodeObject *)func->func_code;
4897 [ - + ]: 122742764 : DEOPT_IF(code->co_argcount != argcount, CALL);
4898 [ + + ]: 122742764 : DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL);
4899 : : STAT_INC(CALL, hit);
4900 : 122738960 : _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, func);
4901 : : CALL_STAT_INC(inlined_py_calls);
4902 : 122738960 : STACK_SHRINK(argcount);
4903 [ + + ]: 366331228 : for (int i = 0; i < argcount; i++) {
4904 : 243592268 : new_frame->localsplus[i] = stack_pointer[i];
4905 : : }
4906 [ + + ]: 376063262 : for (int i = argcount; i < code->co_nlocalsplus; i++) {
4907 : 253324302 : new_frame->localsplus[i] = NULL;
4908 : : }
4909 : 122738960 : STACK_SHRINK(2-is_meth);
4910 : 122738960 : _PyFrame_SetStackPointer(frame, stack_pointer);
4911 : 122738960 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
4912 : 122738960 : frame->prev_instr = next_instr - 1;
4913 : 122738960 : new_frame->previous = frame;
4914 : 122738960 : frame = cframe.current_frame = new_frame;
4915 : 122738960 : goto start_frame;
4916 : : }
4917 : :
4918 : 20417356 : TARGET(CALL_PY_WITH_DEFAULTS) {
4919 : : assert(call_shape.kwnames == NULL);
4920 [ + + ]: 20417356 : DEOPT_IF(tstate->interp->eval_frame, CALL);
4921 : 20417303 : _PyCallCache *cache = (_PyCallCache *)next_instr;
4922 : 20417303 : int is_meth = is_method(stack_pointer, oparg);
4923 : 20417303 : int argcount = oparg + is_meth;
4924 : 20417303 : PyObject *callable = PEEK(argcount + 1);
4925 [ + + ]: 20417303 : DEOPT_IF(!PyFunction_Check(callable), CALL);
4926 : 20415045 : PyFunctionObject *func = (PyFunctionObject *)callable;
4927 [ + + ]: 20415045 : DEOPT_IF(func->func_version != read_u32(cache->func_version), CALL);
4928 : 20297108 : PyCodeObject *code = (PyCodeObject *)func->func_code;
4929 [ - + ]: 20297108 : DEOPT_IF(argcount > code->co_argcount, CALL);
4930 : 20297108 : int minargs = cache->min_args;
4931 [ - + ]: 20297108 : DEOPT_IF(argcount < minargs, CALL);
4932 [ + + ]: 20297108 : DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL);
4933 : : STAT_INC(CALL, hit);
4934 : 20297024 : _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, func);
4935 : : CALL_STAT_INC(inlined_py_calls);
4936 : 20297024 : STACK_SHRINK(argcount);
4937 [ + + ]: 71473492 : for (int i = 0; i < argcount; i++) {
4938 : 51176468 : new_frame->localsplus[i] = stack_pointer[i];
4939 : : }
4940 [ + + ]: 45780426 : for (int i = argcount; i < code->co_argcount; i++) {
4941 : 25483402 : PyObject *def = PyTuple_GET_ITEM(func->func_defaults,
4942 : : i - minargs);
4943 : 25483402 : Py_INCREF(def);
4944 : 25483402 : new_frame->localsplus[i] = def;
4945 : : }
4946 [ + + ]: 81434766 : for (int i = code->co_argcount; i < code->co_nlocalsplus; i++) {
4947 : 61137742 : new_frame->localsplus[i] = NULL;
4948 : : }
4949 : 20297024 : STACK_SHRINK(2-is_meth);
4950 : 20297024 : _PyFrame_SetStackPointer(frame, stack_pointer);
4951 : 20297024 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
4952 : 20297024 : frame->prev_instr = next_instr - 1;
4953 : 20297024 : new_frame->previous = frame;
4954 : 20297024 : frame = cframe.current_frame = new_frame;
4955 : 20297024 : goto start_frame;
4956 : : }
4957 : :
4958 : 30833657 : TARGET(CALL_NO_KW_TYPE_1) {
4959 : : assert(call_shape.kwnames == NULL);
4960 : : assert(cframe.use_tracing == 0);
4961 : : assert(oparg == 1);
4962 [ - + ]: 30833657 : DEOPT_IF(is_method(stack_pointer, 1), CALL);
4963 : 30833657 : PyObject *obj = TOP();
4964 : 30833657 : PyObject *callable = SECOND();
4965 [ - + ]: 30833657 : DEOPT_IF(callable != (PyObject *)&PyType_Type, CALL);
4966 : : STAT_INC(CALL, hit);
4967 : 30833657 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
4968 : 30833657 : PyObject *res = Py_NewRef(Py_TYPE(obj));
4969 [ - + ]: 30833657 : Py_DECREF(callable);
4970 [ + + ]: 30833657 : Py_DECREF(obj);
4971 : 30833657 : STACK_SHRINK(2);
4972 : 30833657 : SET_TOP(res);
4973 : 30833657 : NOTRACE_DISPATCH();
4974 : : }
4975 : :
4976 : 4559449 : TARGET(CALL_NO_KW_STR_1) {
4977 : : assert(call_shape.kwnames == NULL);
4978 : : assert(cframe.use_tracing == 0);
4979 : : assert(oparg == 1);
4980 [ - + ]: 4559449 : DEOPT_IF(is_method(stack_pointer, 1), CALL);
4981 : 4559449 : PyObject *callable = PEEK(2);
4982 [ + + ]: 4559449 : DEOPT_IF(callable != (PyObject *)&PyUnicode_Type, CALL);
4983 : : STAT_INC(CALL, hit);
4984 : 4559068 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
4985 : 4559068 : PyObject *arg = TOP();
4986 : 4559068 : PyObject *res = PyObject_Str(arg);
4987 [ + + ]: 4559068 : Py_DECREF(arg);
4988 [ - + ]: 4559068 : Py_DECREF(&PyUnicode_Type);
4989 : 4559068 : STACK_SHRINK(2);
4990 : 4559068 : SET_TOP(res);
4991 [ + + ]: 4559068 : if (res == NULL) {
4992 : 6 : goto error;
4993 : : }
4994 [ - + ]: 4559062 : CHECK_EVAL_BREAKER();
4995 : 4559062 : DISPATCH();
4996 : : }
4997 : :
4998 : 803554 : TARGET(CALL_NO_KW_TUPLE_1) {
4999 : : assert(call_shape.kwnames == NULL);
5000 : : assert(oparg == 1);
5001 [ - + ]: 803554 : DEOPT_IF(is_method(stack_pointer, 1), CALL);
5002 : 803554 : PyObject *callable = PEEK(2);
5003 [ + + ]: 803554 : DEOPT_IF(callable != (PyObject *)&PyTuple_Type, CALL);
5004 : : STAT_INC(CALL, hit);
5005 : 803373 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5006 : 803373 : PyObject *arg = TOP();
5007 : 803373 : PyObject *res = PySequence_Tuple(arg);
5008 [ + + ]: 803373 : Py_DECREF(arg);
5009 [ - + ]: 803373 : Py_DECREF(&PyTuple_Type);
5010 : 803373 : STACK_SHRINK(2);
5011 : 803373 : SET_TOP(res);
5012 [ + + ]: 803373 : if (res == NULL) {
5013 : 53 : goto error;
5014 : : }
5015 [ + + ]: 803320 : CHECK_EVAL_BREAKER();
5016 : 803319 : DISPATCH();
5017 : : }
5018 : :
5019 : 16450443 : TARGET(CALL_BUILTIN_CLASS) {
5020 : 16450443 : int is_meth = is_method(stack_pointer, oparg);
5021 : 16450443 : int total_args = oparg + is_meth;
5022 [ + + ]: 16450443 : int kwnames_len = KWNAMES_LEN();
5023 : 16450443 : PyObject *callable = PEEK(total_args + 1);
5024 [ + + ]: 16450443 : DEOPT_IF(!PyType_Check(callable), CALL);
5025 : 16449810 : PyTypeObject *tp = (PyTypeObject *)callable;
5026 [ + + ]: 16449810 : DEOPT_IF(tp->tp_vectorcall == NULL, CALL);
5027 : : STAT_INC(CALL, hit);
5028 : 16446804 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5029 : 16446804 : STACK_SHRINK(total_args);
5030 : 16446804 : PyObject *res = tp->tp_vectorcall((PyObject *)tp, stack_pointer,
5031 : 16446804 : total_args-kwnames_len, call_shape.kwnames);
5032 : 16446804 : call_shape.kwnames = NULL;
5033 : : /* Free the arguments. */
5034 [ + + ]: 26278395 : for (int i = 0; i < total_args; i++) {
5035 [ + + ]: 9831591 : Py_DECREF(stack_pointer[i]);
5036 : : }
5037 [ - + ]: 16446804 : Py_DECREF(tp);
5038 : 16446804 : STACK_SHRINK(1-is_meth);
5039 : 16446804 : SET_TOP(res);
5040 [ + + ]: 16446804 : if (res == NULL) {
5041 : 1340 : goto error;
5042 : : }
5043 [ + + ]: 16445464 : CHECK_EVAL_BREAKER();
5044 : 16445334 : DISPATCH();
5045 : : }
5046 : :
5047 : 63590351 : TARGET(CALL_NO_KW_BUILTIN_O) {
5048 : : assert(cframe.use_tracing == 0);
5049 : : /* Builtin METH_O functions */
5050 : : assert(call_shape.kwnames == NULL);
5051 : 63590351 : int is_meth = is_method(stack_pointer, oparg);
5052 : 63590351 : int total_args = oparg + is_meth;
5053 [ + + ]: 63590351 : DEOPT_IF(total_args != 1, CALL);
5054 : 63590343 : PyObject *callable = PEEK(total_args + 1);
5055 [ + + ]: 63590343 : DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
5056 [ + + ]: 63588135 : DEOPT_IF(PyCFunction_GET_FLAGS(callable) != METH_O, CALL);
5057 : : STAT_INC(CALL, hit);
5058 : 63272175 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5059 : 63272175 : PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable);
5060 : : // This is slower but CPython promises to check all non-vectorcall
5061 : : // function calls.
5062 [ + + ]: 63272175 : if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
5063 : 2 : goto error;
5064 : : }
5065 : 63272173 : PyObject *arg = TOP();
5066 : 63272173 : PyObject *res = cfunc(PyCFunction_GET_SELF(callable), arg);
5067 : 63272141 : _Py_LeaveRecursiveCallTstate(tstate);
5068 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5069 : :
5070 [ + + ]: 63272141 : Py_DECREF(arg);
5071 [ + + ]: 63272141 : Py_DECREF(callable);
5072 : 63272141 : STACK_SHRINK(2-is_meth);
5073 : 63272141 : SET_TOP(res);
5074 [ + + ]: 63272141 : if (res == NULL) {
5075 : 7169 : goto error;
5076 : : }
5077 [ + + ]: 63264972 : CHECK_EVAL_BREAKER();
5078 : 63264209 : DISPATCH();
5079 : : }
5080 : :
5081 : 60661319 : TARGET(CALL_NO_KW_BUILTIN_FAST) {
5082 : : assert(cframe.use_tracing == 0);
5083 : : /* Builtin METH_FASTCALL functions, without keywords */
5084 : : assert(call_shape.kwnames == NULL);
5085 : 60661319 : int is_meth = is_method(stack_pointer, oparg);
5086 : 60661319 : int total_args = oparg + is_meth;
5087 : 60661319 : PyObject *callable = PEEK(total_args + 1);
5088 [ + + ]: 60661319 : DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
5089 [ + + ]: 60656642 : DEOPT_IF(PyCFunction_GET_FLAGS(callable) != METH_FASTCALL,
5090 : : CALL);
5091 : : STAT_INC(CALL, hit);
5092 : 60582111 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5093 : 60582111 : PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable);
5094 : 60582111 : STACK_SHRINK(total_args);
5095 : : /* res = func(self, args, nargs) */
5096 : 60582111 : PyObject *res = ((_PyCFunctionFast)(void(*)(void))cfunc)(
5097 : : PyCFunction_GET_SELF(callable),
5098 : : stack_pointer,
5099 : : total_args);
5100 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5101 : :
5102 : : /* Free the arguments. */
5103 [ + + ]: 197135364 : for (int i = 0; i < total_args; i++) {
5104 [ + + ]: 136553282 : Py_DECREF(stack_pointer[i]);
5105 : : }
5106 : 60582082 : STACK_SHRINK(2-is_meth);
5107 : 60582082 : PUSH(res);
5108 [ + + ]: 60582082 : Py_DECREF(callable);
5109 [ + + ]: 60582082 : if (res == NULL) {
5110 : : /* Not deopting because this doesn't mean our optimization was
5111 : : wrong. `res` can be NULL for valid reasons. Eg. getattr(x,
5112 : : 'invalid'). In those cases an exception is set, so we must
5113 : : handle it.
5114 : : */
5115 : 1254413 : goto error;
5116 : : }
5117 [ + + ]: 59327669 : CHECK_EVAL_BREAKER();
5118 : 59325761 : DISPATCH();
5119 : : }
5120 : :
5121 : 8926863 : TARGET(CALL_BUILTIN_FAST_WITH_KEYWORDS) {
5122 : : assert(cframe.use_tracing == 0);
5123 : : /* Builtin METH_FASTCALL | METH_KEYWORDS functions */
5124 : 8926863 : int is_meth = is_method(stack_pointer, oparg);
5125 : 8926863 : int total_args = oparg + is_meth;
5126 : 8926863 : PyObject *callable = PEEK(total_args + 1);
5127 [ + + ]: 8926863 : DEOPT_IF(!PyCFunction_CheckExact(callable), CALL);
5128 [ + + ]: 8923496 : DEOPT_IF(PyCFunction_GET_FLAGS(callable) !=
5129 : : (METH_FASTCALL | METH_KEYWORDS), CALL);
5130 : : STAT_INC(CALL, hit);
5131 : 8471771 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5132 : 8471771 : STACK_SHRINK(total_args);
5133 : : /* res = func(self, args, nargs, kwnames) */
5134 : : _PyCFunctionFastWithKeywords cfunc =
5135 : : (_PyCFunctionFastWithKeywords)(void(*)(void))
5136 : 8471771 : PyCFunction_GET_FUNCTION(callable);
5137 : 8471771 : PyObject *res = cfunc(
5138 : : PyCFunction_GET_SELF(callable),
5139 : : stack_pointer,
5140 [ + + ]: 8471771 : total_args - KWNAMES_LEN(),
5141 : : call_shape.kwnames
5142 : : );
5143 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5144 : 8471770 : call_shape.kwnames = NULL;
5145 : :
5146 : : /* Free the arguments. */
5147 [ + + ]: 21613451 : for (int i = 0; i < total_args; i++) {
5148 [ + + ]: 13141681 : Py_DECREF(stack_pointer[i]);
5149 : : }
5150 : 8471770 : STACK_SHRINK(2-is_meth);
5151 : 8471770 : PUSH(res);
5152 [ + + ]: 8471770 : Py_DECREF(callable);
5153 [ + + ]: 8471770 : if (res == NULL) {
5154 : 274580 : goto error;
5155 : : }
5156 [ + + ]: 8197190 : CHECK_EVAL_BREAKER();
5157 : 8197160 : DISPATCH();
5158 : : }
5159 : :
5160 : 30922919 : TARGET(CALL_NO_KW_LEN) {
5161 : : assert(cframe.use_tracing == 0);
5162 : : assert(call_shape.kwnames == NULL);
5163 : : /* len(o) */
5164 : 30922919 : int is_meth = is_method(stack_pointer, oparg);
5165 : 30922919 : int total_args = oparg + is_meth;
5166 [ - + ]: 30922919 : DEOPT_IF(total_args != 1, CALL);
5167 : 30922919 : PyObject *callable = PEEK(total_args + 1);
5168 : 30922919 : PyInterpreterState *interp = _PyInterpreterState_GET();
5169 [ + + ]: 30922919 : DEOPT_IF(callable != interp->callable_cache.len, CALL);
5170 : : STAT_INC(CALL, hit);
5171 : 30922866 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5172 : 30922866 : PyObject *arg = TOP();
5173 : 30922866 : Py_ssize_t len_i = PyObject_Length(arg);
5174 [ + + ]: 30922866 : if (len_i < 0) {
5175 : 319 : goto error;
5176 : : }
5177 : 30922547 : PyObject *res = PyLong_FromSsize_t(len_i);
5178 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5179 : :
5180 : 30922547 : STACK_SHRINK(2-is_meth);
5181 : 30922547 : SET_TOP(res);
5182 [ - + ]: 30922547 : Py_DECREF(callable);
5183 [ + + ]: 30922547 : Py_DECREF(arg);
5184 [ - + ]: 30922547 : if (res == NULL) {
5185 : 0 : goto error;
5186 : : }
5187 : 30922547 : DISPATCH();
5188 : : }
5189 : :
5190 : 35806995 : TARGET(CALL_NO_KW_ISINSTANCE) {
5191 : : assert(cframe.use_tracing == 0);
5192 : : assert(call_shape.kwnames == NULL);
5193 : : /* isinstance(o, o2) */
5194 : 35806995 : int is_meth = is_method(stack_pointer, oparg);
5195 : 35806995 : int total_args = oparg + is_meth;
5196 : 35806995 : PyObject *callable = PEEK(total_args + 1);
5197 [ - + ]: 35806995 : DEOPT_IF(total_args != 2, CALL);
5198 : 35806995 : PyInterpreterState *interp = _PyInterpreterState_GET();
5199 [ + + ]: 35806995 : DEOPT_IF(callable != interp->callable_cache.isinstance, CALL);
5200 : : STAT_INC(CALL, hit);
5201 : 35806955 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5202 : 35806955 : PyObject *cls = POP();
5203 : 35806955 : PyObject *inst = TOP();
5204 : 35806955 : int retval = PyObject_IsInstance(inst, cls);
5205 [ + + ]: 35806955 : if (retval < 0) {
5206 [ + + ]: 16 : Py_DECREF(cls);
5207 : 16 : goto error;
5208 : : }
5209 : 35806939 : PyObject *res = PyBool_FromLong(retval);
5210 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5211 : :
5212 : 35806939 : STACK_SHRINK(2-is_meth);
5213 : 35806939 : SET_TOP(res);
5214 [ + + ]: 35806939 : Py_DECREF(inst);
5215 [ + + ]: 35806939 : Py_DECREF(cls);
5216 [ - + ]: 35806939 : Py_DECREF(callable);
5217 [ - + ]: 35806939 : if (res == NULL) {
5218 : 0 : goto error;
5219 : : }
5220 : 35806939 : DISPATCH();
5221 : : }
5222 : :
5223 : 15065975 : TARGET(CALL_NO_KW_LIST_APPEND) {
5224 : : assert(cframe.use_tracing == 0);
5225 : : assert(call_shape.kwnames == NULL);
5226 : : assert(oparg == 1);
5227 : 15065975 : PyObject *callable = PEEK(3);
5228 : 15065975 : PyInterpreterState *interp = _PyInterpreterState_GET();
5229 [ + + ]: 15065975 : DEOPT_IF(callable != interp->callable_cache.list_append, CALL);
5230 : 15065883 : PyObject *list = SECOND();
5231 [ - + ]: 15065883 : DEOPT_IF(!PyList_Check(list), CALL);
5232 : : STAT_INC(CALL, hit);
5233 : : // CALL + POP_TOP
5234 : 15065883 : JUMPBY(INLINE_CACHE_ENTRIES_CALL + 1);
5235 : : assert(_Py_OPCODE(next_instr[-1]) == POP_TOP);
5236 : 15065883 : PyObject *arg = POP();
5237 [ - + ]: 15065883 : if (_PyList_AppendTakeRef((PyListObject *)list, arg) < 0) {
5238 : 0 : goto error;
5239 : : }
5240 : 15065883 : STACK_SHRINK(2);
5241 [ - + ]: 15065883 : Py_DECREF(list);
5242 [ - + ]: 15065883 : Py_DECREF(callable);
5243 : 15065883 : NOTRACE_DISPATCH();
5244 : : }
5245 : :
5246 : 19213241 : TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_O) {
5247 : : assert(call_shape.kwnames == NULL);
5248 : 19213241 : int is_meth = is_method(stack_pointer, oparg);
5249 : 19213241 : int total_args = oparg + is_meth;
5250 : 19213241 : PyMethodDescrObject *callable =
5251 : 19213241 : (PyMethodDescrObject *)PEEK(total_args + 1);
5252 [ + + ]: 19213241 : DEOPT_IF(total_args != 2, CALL);
5253 [ + + ]: 19213169 : DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
5254 : 19211195 : PyMethodDef *meth = callable->d_method;
5255 [ + + ]: 19211195 : DEOPT_IF(meth->ml_flags != METH_O, CALL);
5256 : 19209836 : PyObject *arg = TOP();
5257 : 19209836 : PyObject *self = SECOND();
5258 [ + + ]: 19209836 : DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
5259 : : STAT_INC(CALL, hit);
5260 : 18956560 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5261 : 18956560 : PyCFunction cfunc = meth->ml_meth;
5262 : : // This is slower but CPython promises to check all non-vectorcall
5263 : : // function calls.
5264 [ - + ]: 18956560 : if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
5265 : 0 : goto error;
5266 : : }
5267 : 18956560 : PyObject *res = cfunc(self, arg);
5268 : 18956560 : _Py_LeaveRecursiveCallTstate(tstate);
5269 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5270 [ + + ]: 18956560 : Py_DECREF(self);
5271 [ + + ]: 18956560 : Py_DECREF(arg);
5272 : 18956560 : STACK_SHRINK(oparg + 1);
5273 : 18956560 : SET_TOP(res);
5274 [ - + ]: 18956560 : Py_DECREF(callable);
5275 [ + + ]: 18956560 : if (res == NULL) {
5276 : 10056 : goto error;
5277 : : }
5278 [ + + ]: 18946504 : CHECK_EVAL_BREAKER();
5279 : 18946475 : DISPATCH();
5280 : : }
5281 : :
5282 : 16062419 : TARGET(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS) {
5283 : 16062419 : int is_meth = is_method(stack_pointer, oparg);
5284 : 16062419 : int total_args = oparg + is_meth;
5285 : 16062419 : PyMethodDescrObject *callable =
5286 : 16062419 : (PyMethodDescrObject *)PEEK(total_args + 1);
5287 [ + + ]: 16062419 : DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
5288 : 16060262 : PyMethodDef *meth = callable->d_method;
5289 [ + + ]: 16060262 : DEOPT_IF(meth->ml_flags != (METH_FASTCALL|METH_KEYWORDS), CALL);
5290 : 16058883 : PyTypeObject *d_type = callable->d_common.d_type;
5291 : 16058883 : PyObject *self = PEEK(total_args);
5292 [ + + ]: 16058883 : DEOPT_IF(!Py_IS_TYPE(self, d_type), CALL);
5293 : : STAT_INC(CALL, hit);
5294 : 15997644 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5295 : 15997644 : int nargs = total_args-1;
5296 : 15997644 : STACK_SHRINK(nargs);
5297 : 15997644 : _PyCFunctionFastWithKeywords cfunc =
5298 : : (_PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth;
5299 [ - + ]: 15997644 : PyObject *res = cfunc(self, stack_pointer, nargs - KWNAMES_LEN(),
5300 : : call_shape.kwnames);
5301 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5302 : 15997644 : call_shape.kwnames = NULL;
5303 : :
5304 : : /* Free the arguments. */
5305 [ + + ]: 36117987 : for (int i = 0; i < nargs; i++) {
5306 [ + + ]: 20120343 : Py_DECREF(stack_pointer[i]);
5307 : : }
5308 [ + + ]: 15997644 : Py_DECREF(self);
5309 : 15997644 : STACK_SHRINK(2-is_meth);
5310 : 15997644 : SET_TOP(res);
5311 [ - + ]: 15997644 : Py_DECREF(callable);
5312 [ + + ]: 15997644 : if (res == NULL) {
5313 : 2729 : goto error;
5314 : : }
5315 [ + + ]: 15994915 : CHECK_EVAL_BREAKER();
5316 : 15994904 : DISPATCH();
5317 : : }
5318 : :
5319 : 48276048 : TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_NOARGS) {
5320 : : assert(call_shape.kwnames == NULL);
5321 : : assert(oparg == 0 || oparg == 1);
5322 : 48276048 : int is_meth = is_method(stack_pointer, oparg);
5323 : 48276048 : int total_args = oparg + is_meth;
5324 [ + + ]: 48276048 : DEOPT_IF(total_args != 1, CALL);
5325 : 48275782 : PyMethodDescrObject *callable = (PyMethodDescrObject *)SECOND();
5326 [ + + ]: 48275782 : DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
5327 : 48268455 : PyMethodDef *meth = callable->d_method;
5328 : 48268455 : PyObject *self = TOP();
5329 [ + + ]: 48268455 : DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
5330 [ + + ]: 47895108 : DEOPT_IF(meth->ml_flags != METH_NOARGS, CALL);
5331 : : STAT_INC(CALL, hit);
5332 : 47894965 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5333 : 47894965 : PyCFunction cfunc = meth->ml_meth;
5334 : : // This is slower but CPython promises to check all non-vectorcall
5335 : : // function calls.
5336 [ - + ]: 47894965 : if (_Py_EnterRecursiveCallTstate(tstate, " while calling a Python object")) {
5337 : 0 : goto error;
5338 : : }
5339 : 47894965 : PyObject *res = cfunc(self, NULL);
5340 : 47894964 : _Py_LeaveRecursiveCallTstate(tstate);
5341 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5342 [ + + ]: 47894964 : Py_DECREF(self);
5343 : 47894964 : STACK_SHRINK(oparg + 1);
5344 : 47894964 : SET_TOP(res);
5345 [ - + ]: 47894964 : Py_DECREF(callable);
5346 [ + + ]: 47894964 : if (res == NULL) {
5347 : 189805 : goto error;
5348 : : }
5349 [ + + ]: 47705159 : CHECK_EVAL_BREAKER();
5350 : 47703211 : DISPATCH();
5351 : : }
5352 : :
5353 : 47573747 : TARGET(CALL_NO_KW_METHOD_DESCRIPTOR_FAST) {
5354 : : assert(call_shape.kwnames == NULL);
5355 : 47573747 : int is_meth = is_method(stack_pointer, oparg);
5356 : 47573747 : int total_args = oparg + is_meth;
5357 : 47573747 : PyMethodDescrObject *callable =
5358 : 47573747 : (PyMethodDescrObject *)PEEK(total_args + 1);
5359 : : /* Builtin METH_FASTCALL methods, without keywords */
5360 [ + + ]: 47573747 : DEOPT_IF(!Py_IS_TYPE(callable, &PyMethodDescr_Type), CALL);
5361 : 47567748 : PyMethodDef *meth = callable->d_method;
5362 [ + + ]: 47567748 : DEOPT_IF(meth->ml_flags != METH_FASTCALL, CALL);
5363 : 47567570 : PyObject *self = PEEK(total_args);
5364 [ + + ]: 47567570 : DEOPT_IF(!Py_IS_TYPE(self, callable->d_common.d_type), CALL);
5365 : : STAT_INC(CALL, hit);
5366 : 47502243 : JUMPBY(INLINE_CACHE_ENTRIES_CALL);
5367 : 47502243 : _PyCFunctionFast cfunc =
5368 : : (_PyCFunctionFast)(void(*)(void))meth->ml_meth;
5369 : 47502243 : int nargs = total_args-1;
5370 : 47502243 : STACK_SHRINK(nargs);
5371 : 47502243 : PyObject *res = cfunc(self, stack_pointer, nargs);
5372 : : assert((res != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
5373 : : /* Clear the stack of the arguments. */
5374 [ + + ]: 98626047 : for (int i = 0; i < nargs; i++) {
5375 [ + + ]: 51123804 : Py_DECREF(stack_pointer[i]);
5376 : : }
5377 [ + + ]: 47502243 : Py_DECREF(self);
5378 : 47502243 : STACK_SHRINK(2-is_meth);
5379 : 47502243 : SET_TOP(res);
5380 [ - + ]: 47502243 : Py_DECREF(callable);
5381 [ + + ]: 47502243 : if (res == NULL) {
5382 : 282214 : goto error;
5383 : : }
5384 [ + + ]: 47220029 : CHECK_EVAL_BREAKER();
5385 : 47219423 : DISPATCH();
5386 : : }
5387 : :
5388 : 9573983 : TARGET(CALL_FUNCTION_EX) {
5389 : 9573983 : PREDICTED(CALL_FUNCTION_EX);
5390 : 9573983 : PyObject *func, *callargs, *kwargs = NULL, *result;
5391 [ + + ]: 9573983 : if (oparg & 0x01) {
5392 : 3433865 : kwargs = POP();
5393 [ - + ]: 3433865 : if (!PyDict_CheckExact(kwargs)) {
5394 : 0 : PyObject *d = PyDict_New();
5395 [ # # ]: 0 : if (d == NULL)
5396 : 0 : goto error;
5397 [ # # ]: 0 : if (_PyDict_MergeEx(d, kwargs, 2) < 0) {
5398 [ # # ]: 0 : Py_DECREF(d);
5399 : 0 : format_kwargs_error(tstate, SECOND(), kwargs);
5400 [ # # ]: 0 : Py_DECREF(kwargs);
5401 : 0 : goto error;
5402 : : }
5403 [ # # ]: 0 : Py_DECREF(kwargs);
5404 : 0 : kwargs = d;
5405 : : }
5406 : : assert(PyDict_CheckExact(kwargs));
5407 : : }
5408 : 9573983 : callargs = POP();
5409 : 9573983 : func = TOP();
5410 [ + + ]: 9573983 : if (!PyTuple_CheckExact(callargs)) {
5411 [ + + ]: 344035 : if (check_args_iterable(tstate, func, callargs) < 0) {
5412 [ + + ]: 6 : Py_DECREF(callargs);
5413 : 6 : goto error;
5414 : : }
5415 [ + + ]: 344029 : Py_SETREF(callargs, PySequence_Tuple(callargs));
5416 [ + + ]: 344029 : if (callargs == NULL) {
5417 : 4 : goto error;
5418 : : }
5419 : : }
5420 : : assert(PyTuple_CheckExact(callargs));
5421 : :
5422 : 9573973 : result = do_call_core(tstate, func, callargs, kwargs, cframe.use_tracing);
5423 [ + + ]: 9573834 : Py_DECREF(func);
5424 [ + + ]: 9573834 : Py_DECREF(callargs);
5425 [ + + + + ]: 9573834 : Py_XDECREF(kwargs);
5426 : :
5427 : 9573834 : STACK_SHRINK(1);
5428 : : assert(TOP() == NULL);
5429 : 9573834 : SET_TOP(result);
5430 [ + + ]: 9573834 : if (result == NULL) {
5431 : 141301 : goto error;
5432 : : }
5433 [ + + ]: 9432533 : CHECK_EVAL_BREAKER();
5434 : 9429159 : DISPATCH();
5435 : : }
5436 : :
5437 : 14551168 : TARGET(MAKE_FUNCTION) {
5438 : 14551168 : PyObject *codeobj = POP();
5439 : : PyFunctionObject *func = (PyFunctionObject *)
5440 : 14551168 : PyFunction_New(codeobj, GLOBALS());
5441 : :
5442 [ - + ]: 14551168 : Py_DECREF(codeobj);
5443 [ - + ]: 14551168 : if (func == NULL) {
5444 : 0 : goto error;
5445 : : }
5446 : :
5447 [ + + ]: 14551168 : if (oparg & 0x08) {
5448 : : assert(PyTuple_CheckExact(TOP()));
5449 : 2428020 : func->func_closure = POP();
5450 : : }
5451 [ + + ]: 14551168 : if (oparg & 0x04) {
5452 : : assert(PyTuple_CheckExact(TOP()));
5453 : 120046 : func->func_annotations = POP();
5454 : : }
5455 [ + + ]: 14551168 : if (oparg & 0x02) {
5456 : : assert(PyDict_CheckExact(TOP()));
5457 : 262425 : func->func_kwdefaults = POP();
5458 : : }
5459 [ + + ]: 14551168 : if (oparg & 0x01) {
5460 : : assert(PyTuple_CheckExact(TOP()));
5461 : 1620900 : func->func_defaults = POP();
5462 : : }
5463 : :
5464 : 14551168 : PUSH((PyObject *)func);
5465 : 14551168 : DISPATCH();
5466 : : }
5467 : :
5468 : 17063267 : TARGET(RETURN_GENERATOR) {
5469 : 17063267 : PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(frame->f_func);
5470 [ - + ]: 17063267 : if (gen == NULL) {
5471 : 0 : goto error;
5472 : : }
5473 : : assert(EMPTY());
5474 : 17063267 : _PyFrame_SetStackPointer(frame, stack_pointer);
5475 : 17063267 : _PyInterpreterFrame *gen_frame = (_PyInterpreterFrame *)gen->gi_iframe;
5476 : 17063267 : _PyFrame_Copy(frame, gen_frame);
5477 : : assert(frame->frame_obj == NULL);
5478 : 17063267 : gen->gi_frame_state = FRAME_CREATED;
5479 : 17063267 : gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
5480 : 17063267 : _Py_LeaveRecursiveCallTstate(tstate);
5481 [ + + ]: 17063267 : if (!frame->is_entry) {
5482 : 15906666 : _PyInterpreterFrame *prev = frame->previous;
5483 : 15906666 : _PyThreadState_PopFrame(tstate, frame);
5484 : 15906666 : frame = cframe.current_frame = prev;
5485 : 15906666 : _PyFrame_StackPush(frame, (PyObject *)gen);
5486 : 15906666 : goto resume_frame;
5487 : : }
5488 : : /* Make sure that frame is in a valid state */
5489 : 1156601 : frame->stacktop = 0;
5490 : 1156601 : frame->f_locals = NULL;
5491 : 1156601 : Py_INCREF(frame->f_func);
5492 : 1156601 : Py_INCREF(frame->f_code);
5493 : : /* Restore previous cframe and return. */
5494 : 1156601 : tstate->cframe = cframe.previous;
5495 : 1156601 : tstate->cframe->use_tracing = cframe.use_tracing;
5496 : : assert(tstate->cframe->current_frame == frame->previous);
5497 : : assert(!_PyErr_Occurred(tstate));
5498 : 1156601 : return (PyObject *)gen;
5499 : : }
5500 : :
5501 : 618691 : TARGET(BUILD_SLICE) {
5502 : : PyObject *start, *stop, *step, *slice;
5503 [ + + ]: 618691 : if (oparg == 3)
5504 : 543558 : step = POP();
5505 : : else
5506 : 75133 : step = NULL;
5507 : 618691 : stop = POP();
5508 : 618691 : start = TOP();
5509 : 618691 : slice = PySlice_New(start, stop, step);
5510 [ - + ]: 618691 : Py_DECREF(start);
5511 [ - + ]: 618691 : Py_DECREF(stop);
5512 [ + + - + ]: 618691 : Py_XDECREF(step);
5513 : 618691 : SET_TOP(slice);
5514 [ - + ]: 618691 : if (slice == NULL)
5515 : 0 : goto error;
5516 : 618691 : DISPATCH();
5517 : : }
5518 : :
5519 : 3090822 : TARGET(FORMAT_VALUE) {
5520 : : /* Handles f-string value formatting. */
5521 : : PyObject *result;
5522 : : PyObject *fmt_spec;
5523 : : PyObject *value;
5524 : : PyObject *(*conv_fn)(PyObject *);
5525 : 3090822 : int which_conversion = oparg & FVC_MASK;
5526 : 3090822 : int have_fmt_spec = (oparg & FVS_MASK) == FVS_HAVE_SPEC;
5527 : :
5528 [ + + ]: 3090822 : fmt_spec = have_fmt_spec ? POP() : NULL;
5529 : 3090822 : value = POP();
5530 : :
5531 : : /* See if any conversion is specified. */
5532 [ + + + + : 3090822 : switch (which_conversion) {
- ]
5533 : 1955256 : case FVC_NONE: conv_fn = NULL; break;
5534 : 638029 : case FVC_STR: conv_fn = PyObject_Str; break;
5535 : 493384 : case FVC_REPR: conv_fn = PyObject_Repr; break;
5536 : 4153 : case FVC_ASCII: conv_fn = PyObject_ASCII; break;
5537 : 0 : default:
5538 : 0 : _PyErr_Format(tstate, PyExc_SystemError,
5539 : : "unexpected conversion flag %d",
5540 : : which_conversion);
5541 : 0 : goto error;
5542 : : }
5543 : :
5544 : : /* If there's a conversion function, call it and replace
5545 : : value with that result. Otherwise, just use value,
5546 : : without conversion. */
5547 [ + + ]: 3090822 : if (conv_fn != NULL) {
5548 : 1135566 : result = conv_fn(value);
5549 [ + + ]: 1135566 : Py_DECREF(value);
5550 [ + + ]: 1135566 : if (result == NULL) {
5551 [ - + - - ]: 483 : Py_XDECREF(fmt_spec);
5552 : 483 : goto error;
5553 : : }
5554 : 1135083 : value = result;
5555 : : }
5556 : :
5557 : : /* If value is a unicode object, and there's no fmt_spec,
5558 : : then we know the result of format(value) is value
5559 : : itself. In that case, skip calling format(). I plan to
5560 : : move this optimization in to PyObject_Format()
5561 : : itself. */
5562 [ + + + + ]: 3090339 : if (PyUnicode_CheckExact(value) && fmt_spec == NULL) {
5563 : : /* Do nothing, just transfer ownership to result. */
5564 : 2416679 : result = value;
5565 : : } else {
5566 : : /* Actually call format(). */
5567 : 673660 : result = PyObject_Format(value, fmt_spec);
5568 [ + + ]: 673660 : Py_DECREF(value);
5569 [ + + + + ]: 673660 : Py_XDECREF(fmt_spec);
5570 [ + + ]: 673660 : if (result == NULL) {
5571 : 16 : goto error;
5572 : : }
5573 : : }
5574 : :
5575 : 3090323 : PUSH(result);
5576 : 3090323 : DISPATCH();
5577 : : }
5578 : :
5579 : 22202673 : TARGET(COPY) {
5580 : : assert(oparg != 0);
5581 : 22202673 : PyObject *peek = PEEK(oparg);
5582 : 22202673 : Py_INCREF(peek);
5583 : 22202673 : PUSH(peek);
5584 : 22202673 : DISPATCH();
5585 : : }
5586 : :
5587 : 34691642 : TARGET(BINARY_OP) {
5588 : 42644287 : PREDICTED(BINARY_OP);
5589 : 42644287 : PyObject *rhs = POP();
5590 : 42644287 : PyObject *lhs = TOP();
5591 : : assert(0 <= oparg);
5592 : : assert((unsigned)oparg < Py_ARRAY_LENGTH(binary_ops));
5593 : : assert(binary_ops[oparg]);
5594 : 42644287 : PyObject *res = binary_ops[oparg](lhs, rhs);
5595 [ + + ]: 42644287 : Py_DECREF(lhs);
5596 [ + + ]: 42644287 : Py_DECREF(rhs);
5597 : 42644287 : SET_TOP(res);
5598 [ + + ]: 42644287 : if (res == NULL) {
5599 : 4766 : goto error;
5600 : : }
5601 : 42639521 : JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
5602 : 42639521 : DISPATCH();
5603 : : }
5604 : :
5605 : 8332588 : TARGET(BINARY_OP_ADAPTIVE) {
5606 : : assert(cframe.use_tracing == 0);
5607 : 8332588 : _PyBinaryOpCache *cache = (_PyBinaryOpCache *)next_instr;
5608 [ + + ]: 8332588 : if (ADAPTIVE_COUNTER_IS_ZERO(cache)) {
5609 : 379943 : PyObject *lhs = SECOND();
5610 : 379943 : PyObject *rhs = TOP();
5611 : 379943 : next_instr--;
5612 : 379943 : _Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, &GETLOCAL(0));
5613 : 379943 : NOTRACE_DISPATCH_SAME_OPARG();
5614 : : }
5615 : : else {
5616 : : STAT_INC(BINARY_OP, deferred);
5617 : 7952645 : DECREMENT_ADAPTIVE_COUNTER(cache);
5618 : 7952645 : JUMP_TO_INSTRUCTION(BINARY_OP);
5619 : : }
5620 : : }
5621 : :
5622 : 24426889 : TARGET(SWAP) {
5623 : : assert(oparg != 0);
5624 : 24426889 : PyObject *top = TOP();
5625 : 24426889 : SET_TOP(PEEK(oparg));
5626 : 24426889 : PEEK(oparg) = top;
5627 : 24426889 : DISPATCH();
5628 : : }
5629 : :
5630 : 30096 : TARGET(EXTENDED_ARG) {
5631 : : assert(oparg);
5632 : 30096 : oparg <<= 8;
5633 : 30096 : oparg |= _Py_OPARG(*next_instr);
5634 : 30096 : opcode = _PyOpcode_Deopt[_Py_OPCODE(*next_instr)];
5635 : : PRE_DISPATCH_GOTO();
5636 : 30096 : DISPATCH_GOTO();
5637 : : }
5638 : :
5639 : 61975806 : TARGET(EXTENDED_ARG_QUICK) {
5640 : : assert(oparg);
5641 : 61975806 : oparg <<= 8;
5642 : 61975806 : oparg |= _Py_OPARG(*next_instr);
5643 : 61975806 : NOTRACE_DISPATCH_SAME_OPARG();
5644 : : }
5645 : :
5646 : 0 : TARGET(CACHE) {
5647 : 0 : Py_UNREACHABLE();
5648 : : }
5649 : :
5650 : : #if USE_COMPUTED_GOTOS
5651 : 47271753 : TARGET_DO_TRACING:
5652 : : #else
5653 : : case DO_TRACING:
5654 : : #endif
5655 : : {
5656 [ + + ]: 47271753 : if (tstate->tracing == 0 &&
5657 [ + + ]: 6037141 : INSTR_OFFSET() >= frame->f_code->_co_firsttraceable
5658 : : ) {
5659 : 6029904 : int instr_prev = _PyInterpreterFrame_LASTI(frame);
5660 : 6029904 : frame->prev_instr = next_instr;
5661 : 6029904 : TRACING_NEXTOPARG();
5662 [ + + ]: 6029904 : if (opcode == RESUME) {
5663 [ + + ]: 136554 : if (oparg < 2) {
5664 [ + + ]: 135760 : CHECK_EVAL_BREAKER();
5665 : : }
5666 : : /* Call tracing */
5667 [ + - + + ]: 136544 : TRACE_FUNCTION_ENTRY();
5668 [ - + ]: 135541 : DTRACE_FUNCTION_ENTRY();
5669 : : }
5670 : : else {
5671 : : /* line-by-line tracing support */
5672 [ - + ]: 5893350 : if (PyDTrace_LINE_ENABLED()) {
5673 : 0 : maybe_dtrace_line(frame, &tstate->trace_info, instr_prev);
5674 : : }
5675 : :
5676 [ + - ]: 5893350 : if (cframe.use_tracing &&
5677 [ + + + - ]: 5893350 : tstate->c_tracefunc != NULL && !tstate->tracing) {
5678 : : int err;
5679 : : /* see maybe_call_line_trace()
5680 : : for expository comments */
5681 : 5859013 : _PyFrame_SetStackPointer(frame, stack_pointer);
5682 : :
5683 : 5859013 : err = maybe_call_line_trace(tstate->c_tracefunc,
5684 : : tstate->c_traceobj,
5685 : : tstate, frame, instr_prev);
5686 : : // Reload possibly changed frame fields:
5687 : 5859013 : stack_pointer = _PyFrame_GetStackPointer(frame);
5688 : 5859013 : frame->stacktop = -1;
5689 : : // next_instr is only reloaded if tracing *does not* raise.
5690 : : // This is consistent with the behavior of older Python
5691 : : // versions. If a trace function sets a new f_lineno and
5692 : : // *then* raises, we use the *old* location when searching
5693 : : // for an exception handler, displaying the traceback, and
5694 : : // so on:
5695 [ + + ]: 5859013 : if (err) {
5696 : : // next_instr wasn't incremented at the start of this
5697 : : // instruction. Increment it before handling the error,
5698 : : // so that it looks the same as a "normal" instruction:
5699 : 1080 : next_instr++;
5700 : 1080 : goto error;
5701 : : }
5702 : : // Reload next_instr. Don't increment it, though, since
5703 : : // we're going to re-dispatch to the "true" instruction now:
5704 : 5857933 : next_instr = frame->prev_instr;
5705 : : }
5706 : : }
5707 : : }
5708 : 47269660 : TRACING_NEXTOPARG();
5709 : : PRE_DISPATCH_GOTO();
5710 : 47269660 : DISPATCH_GOTO();
5711 : : }
5712 : :
5713 : : #if USE_COMPUTED_GOTOS
5714 : 0 : _unknown_opcode:
5715 : : #else
5716 : : EXTRA_CASES // From opcode.h, a 'case' for each unused opcode
5717 : : #endif
5718 : : /* Tell C compilers not to hold the opcode variable in the loop.
5719 : : next_instr points the current instruction without TARGET(). */
5720 : 0 : opcode = _Py_OPCODE(*next_instr);
5721 : 0 : fprintf(stderr, "XXX lineno: %d, opcode: %d\n",
5722 : : _PyInterpreterFrame_GetLine(frame), opcode);
5723 : 0 : _PyErr_SetString(tstate, PyExc_SystemError, "unknown opcode");
5724 : 0 : goto error;
5725 : :
5726 : : } /* End instructions */
5727 : :
5728 : : /* This should never be reached. Every opcode should end with DISPATCH()
5729 : : or goto error. */
5730 : : Py_UNREACHABLE();
5731 : :
5732 : : /* Specialization misses */
5733 : :
5734 : 64134679 : miss:
5735 : : {
5736 : : STAT_INC(opcode, miss);
5737 : 64134679 : opcode = _PyOpcode_Deopt[opcode];
5738 : : STAT_INC(opcode, miss);
5739 : : /* The counter is always the first cache entry: */
5740 : 64134679 : _Py_CODEUNIT *counter = (_Py_CODEUNIT *)next_instr;
5741 : 64134679 : *counter -= 1;
5742 [ + + ]: 64134679 : if (*counter == 0) {
5743 : 1064635 : int adaptive_opcode = _PyOpcode_Adaptive[opcode];
5744 : : assert(adaptive_opcode);
5745 : 1064635 : _Py_SET_OPCODE(next_instr[-1], adaptive_opcode);
5746 : : STAT_INC(opcode, deopt);
5747 : 1064635 : *counter = adaptive_counter_start();
5748 : : }
5749 : 64134679 : next_instr--;
5750 : 64134679 : DISPATCH_GOTO();
5751 : : }
5752 : :
5753 : 710122 : binary_subscr_dict_error:
5754 : : {
5755 : 710122 : PyObject *sub = POP();
5756 [ + + ]: 710122 : if (!_PyErr_Occurred(tstate)) {
5757 : 710114 : _PyErr_SetKeyError(sub);
5758 : : }
5759 [ - + ]: 710122 : Py_DECREF(sub);
5760 : 710122 : goto error;
5761 : : }
5762 : :
5763 : 6 : unbound_local_error:
5764 : : {
5765 : 6 : format_exc_check_arg(tstate, PyExc_UnboundLocalError,
5766 : : UNBOUNDLOCAL_ERROR_MSG,
5767 : 6 : PyTuple_GetItem(frame->f_code->co_localsplusnames, oparg)
5768 : : );
5769 : 6 : goto error;
5770 : : }
5771 : :
5772 : 5290311 : error:
5773 : 5290311 : call_shape.kwnames = NULL;
5774 : : /* Double-check exception status. */
5775 : : #ifdef NDEBUG
5776 [ - + ]: 5290311 : if (!_PyErr_Occurred(tstate)) {
5777 : 0 : _PyErr_SetString(tstate, PyExc_SystemError,
5778 : : "error return without exception set");
5779 : : }
5780 : : #else
5781 : : assert(_PyErr_Occurred(tstate));
5782 : : #endif
5783 : :
5784 : : /* Log traceback info. */
5785 : 5290311 : PyFrameObject *f = _PyFrame_GetFrameObject(frame);
5786 [ + + ]: 5290311 : if (f != NULL) {
5787 : 5290273 : PyTraceBack_Here(f);
5788 : : }
5789 : :
5790 [ + + ]: 5290311 : if (tstate->c_tracefunc != NULL) {
5791 : : /* Make sure state is set to FRAME_UNWINDING for tracing */
5792 : 8705 : call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj,
5793 : : tstate, frame);
5794 : : }
5795 : :
5796 : 5290311 : exception_unwind:
5797 : : {
5798 : : /* We can't use frame->f_lasti here, as RERAISE may have set it */
5799 : 5973257 : int offset = INSTR_OFFSET()-1;
5800 : : int level, handler, lasti;
5801 [ + + ]: 5973257 : if (get_exception_handler(frame->f_code, offset, &level, &handler, &lasti) == 0) {
5802 : : // No handlers, so exit.
5803 : : assert(_PyErr_Occurred(tstate));
5804 : :
5805 : : /* Pop remaining stack entries. */
5806 : 1680255 : PyObject **stackbase = _PyFrame_Stackbase(frame);
5807 [ + + ]: 3870953 : while (stack_pointer > stackbase) {
5808 : 2190698 : PyObject *o = POP();
5809 [ + + + + ]: 2190698 : Py_XDECREF(o);
5810 : : }
5811 : : assert(STACK_LEVEL() == 0);
5812 : 1680255 : _PyFrame_SetStackPointer(frame, stack_pointer);
5813 [ + + ]: 1680255 : TRACE_FUNCTION_UNWIND();
5814 [ - + ]: 1680255 : DTRACE_FUNCTION_EXIT();
5815 : 1680255 : goto exit_unwind;
5816 : : }
5817 : :
5818 : : assert(STACK_LEVEL() >= level);
5819 : 4293002 : PyObject **new_top = _PyFrame_Stackbase(frame) + level;
5820 [ + + ]: 8532056 : while (stack_pointer > new_top) {
5821 : 4239054 : PyObject *v = POP();
5822 [ + + + + ]: 4239054 : Py_XDECREF(v);
5823 : : }
5824 : : PyObject *exc, *val, *tb;
5825 [ + + ]: 4293002 : if (lasti) {
5826 : 610629 : int frame_lasti = _PyInterpreterFrame_LASTI(frame);
5827 : 610629 : PyObject *lasti = PyLong_FromLong(frame_lasti);
5828 [ - + ]: 610629 : if (lasti == NULL) {
5829 : 0 : goto exception_unwind;
5830 : : }
5831 : 610629 : PUSH(lasti);
5832 : : }
5833 : 4293002 : _PyErr_Fetch(tstate, &exc, &val, &tb);
5834 : : /* Make the raw exception data
5835 : : available to the handler,
5836 : : so a program can emulate the
5837 : : Python main loop. */
5838 : 4293002 : _PyErr_NormalizeException(tstate, &exc, &val, &tb);
5839 [ + + ]: 4293002 : if (tb != NULL)
5840 : 4292982 : PyException_SetTraceback(val, tb);
5841 : : else
5842 : 20 : PyException_SetTraceback(val, Py_None);
5843 [ + + - + ]: 4293002 : Py_XDECREF(tb);
5844 [ + - - + ]: 4293002 : Py_XDECREF(exc);
5845 : 4293002 : PUSH(val);
5846 : 4293002 : JUMPTO(handler);
5847 : : /* Resume normal execution */
5848 : 4293002 : DISPATCH();
5849 : : }
5850 : : }
5851 : :
5852 : 1689525 : exit_unwind:
5853 : : assert(_PyErr_Occurred(tstate));
5854 : 1689525 : _Py_LeaveRecursiveCallTstate(tstate);
5855 [ + + ]: 1689525 : if (frame->is_entry) {
5856 : : /* Restore previous cframe and exit */
5857 : 1218803 : tstate->cframe = cframe.previous;
5858 : 1218803 : tstate->cframe->use_tracing = cframe.use_tracing;
5859 : : assert(tstate->cframe->current_frame == frame->previous);
5860 : 1218803 : return NULL;
5861 : : }
5862 : 470722 : frame = cframe.current_frame = pop_frame(tstate, frame);
5863 : :
5864 : 1087662 : resume_with_error:
5865 : 1087662 : SET_LOCALS_FROM_FRAME();
5866 : 1087662 : goto error;
5867 : :
5868 : : }
5869 : :
5870 : : static void
5871 : 639 : format_missing(PyThreadState *tstate, const char *kind,
5872 : : PyCodeObject *co, PyObject *names, PyObject *qualname)
5873 : : {
5874 : : int err;
5875 : 639 : Py_ssize_t len = PyList_GET_SIZE(names);
5876 : : PyObject *name_str, *comma, *tail, *tmp;
5877 : :
5878 : : assert(PyList_CheckExact(names));
5879 : : assert(len >= 1);
5880 : : /* Deal with the joys of natural language. */
5881 [ + + + ]: 639 : switch (len) {
5882 : 554 : case 1:
5883 : 554 : name_str = PyList_GET_ITEM(names, 0);
5884 : 554 : Py_INCREF(name_str);
5885 : 554 : break;
5886 : 79 : case 2:
5887 : 79 : name_str = PyUnicode_FromFormat("%U and %U",
5888 : 79 : PyList_GET_ITEM(names, len - 2),
5889 : 79 : PyList_GET_ITEM(names, len - 1));
5890 : 79 : break;
5891 : 6 : default:
5892 : 6 : tail = PyUnicode_FromFormat(", %U, and %U",
5893 : 6 : PyList_GET_ITEM(names, len - 2),
5894 : 6 : PyList_GET_ITEM(names, len - 1));
5895 [ - + ]: 6 : if (tail == NULL)
5896 : 0 : return;
5897 : : /* Chop off the last two objects in the list. This shouldn't actually
5898 : : fail, but we can't be too careful. */
5899 : 6 : err = PyList_SetSlice(names, len - 2, len, NULL);
5900 [ - + ]: 6 : if (err == -1) {
5901 [ # # ]: 0 : Py_DECREF(tail);
5902 : 0 : return;
5903 : : }
5904 : : /* Stitch everything up into a nice comma-separated list. */
5905 : 6 : comma = PyUnicode_FromString(", ");
5906 [ - + ]: 6 : if (comma == NULL) {
5907 [ # # ]: 0 : Py_DECREF(tail);
5908 : 0 : return;
5909 : : }
5910 : 6 : tmp = PyUnicode_Join(comma, names);
5911 [ + - ]: 6 : Py_DECREF(comma);
5912 [ - + ]: 6 : if (tmp == NULL) {
5913 [ # # ]: 0 : Py_DECREF(tail);
5914 : 0 : return;
5915 : : }
5916 : 6 : name_str = PyUnicode_Concat(tmp, tail);
5917 [ + + ]: 6 : Py_DECREF(tmp);
5918 [ + - ]: 6 : Py_DECREF(tail);
5919 : 6 : break;
5920 : : }
5921 [ - + ]: 639 : if (name_str == NULL)
5922 : 0 : return;
5923 [ + + ]: 639 : _PyErr_Format(tstate, PyExc_TypeError,
5924 : : "%U() missing %i required %s argument%s: %U",
5925 : : qualname,
5926 : : len,
5927 : : kind,
5928 : : len == 1 ? "" : "s",
5929 : : name_str);
5930 [ + + ]: 639 : Py_DECREF(name_str);
5931 : : }
5932 : :
5933 : : static void
5934 : 639 : missing_arguments(PyThreadState *tstate, PyCodeObject *co,
5935 : : Py_ssize_t missing, Py_ssize_t defcount,
5936 : : PyObject **localsplus, PyObject *qualname)
5937 : : {
5938 : 639 : Py_ssize_t i, j = 0;
5939 : : Py_ssize_t start, end;
5940 : 639 : int positional = (defcount != -1);
5941 [ + + ]: 639 : const char *kind = positional ? "positional" : "keyword-only";
5942 : : PyObject *missing_names;
5943 : :
5944 : : /* Compute the names of the arguments that are missing. */
5945 : 639 : missing_names = PyList_New(missing);
5946 [ - + ]: 639 : if (missing_names == NULL)
5947 : 0 : return;
5948 [ + + ]: 639 : if (positional) {
5949 : 621 : start = 0;
5950 : 621 : end = co->co_argcount - defcount;
5951 : : }
5952 : : else {
5953 : 18 : start = co->co_argcount;
5954 : 18 : end = start + co->co_kwonlyargcount;
5955 : : }
5956 [ + + ]: 1863 : for (i = start; i < end; i++) {
5957 [ + + ]: 1224 : if (localsplus[i] == NULL) {
5958 : 734 : PyObject *raw = PyTuple_GET_ITEM(co->co_localsplusnames, i);
5959 : 734 : PyObject *name = PyObject_Repr(raw);
5960 [ - + ]: 734 : if (name == NULL) {
5961 [ # # ]: 0 : Py_DECREF(missing_names);
5962 : 0 : return;
5963 : : }
5964 : 734 : PyList_SET_ITEM(missing_names, j++, name);
5965 : : }
5966 : : }
5967 : : assert(j == missing);
5968 : 639 : format_missing(tstate, kind, co, missing_names, qualname);
5969 [ + - ]: 639 : Py_DECREF(missing_names);
5970 : : }
5971 : :
5972 : : static void
5973 : 1294 : too_many_positional(PyThreadState *tstate, PyCodeObject *co,
5974 : : Py_ssize_t given, PyObject *defaults,
5975 : : PyObject **localsplus, PyObject *qualname)
5976 : : {
5977 : : int plural;
5978 : 1294 : Py_ssize_t kwonly_given = 0;
5979 : : Py_ssize_t i;
5980 : : PyObject *sig, *kwonly_sig;
5981 : 1294 : Py_ssize_t co_argcount = co->co_argcount;
5982 : :
5983 : : assert((co->co_flags & CO_VARARGS) == 0);
5984 : : /* Count missing keyword-only args. */
5985 [ + + ]: 1373 : for (i = co_argcount; i < co_argcount + co->co_kwonlyargcount; i++) {
5986 [ + + ]: 79 : if (localsplus[i] != NULL) {
5987 : 7 : kwonly_given++;
5988 : : }
5989 : : }
5990 [ + + ]: 1294 : Py_ssize_t defcount = defaults == NULL ? 0 : PyTuple_GET_SIZE(defaults);
5991 [ + + ]: 1294 : if (defcount) {
5992 : 85 : Py_ssize_t atleast = co_argcount - defcount;
5993 : 85 : plural = 1;
5994 : 85 : sig = PyUnicode_FromFormat("from %zd to %zd", atleast, co_argcount);
5995 : : }
5996 : : else {
5997 : 1209 : plural = (co_argcount != 1);
5998 : 1209 : sig = PyUnicode_FromFormat("%zd", co_argcount);
5999 : : }
6000 [ - + ]: 1294 : if (sig == NULL)
6001 : 0 : return;
6002 [ + + ]: 1294 : if (kwonly_given) {
6003 : 5 : const char *format = " positional argument%s (and %zd keyword-only argument%s)";
6004 [ + + + + ]: 5 : kwonly_sig = PyUnicode_FromFormat(format,
6005 : : given != 1 ? "s" : "",
6006 : : kwonly_given,
6007 : : kwonly_given != 1 ? "s" : "");
6008 [ - + ]: 5 : if (kwonly_sig == NULL) {
6009 [ # # ]: 0 : Py_DECREF(sig);
6010 : 0 : return;
6011 : : }
6012 : : }
6013 : : else {
6014 : : /* This will not fail. */
6015 : 1289 : kwonly_sig = PyUnicode_FromString("");
6016 : : assert(kwonly_sig != NULL);
6017 : : }
6018 [ + + + + ]: 2304 : _PyErr_Format(tstate, PyExc_TypeError,
6019 : : "%U() takes %U positional argument%s but %zd%U %s given",
6020 : : qualname,
6021 : : sig,
6022 : : plural ? "s" : "",
6023 : : given,
6024 : : kwonly_sig,
6025 [ + + ]: 1010 : given == 1 && !kwonly_given ? "was" : "were");
6026 [ + + ]: 1294 : Py_DECREF(sig);
6027 [ + + ]: 1294 : Py_DECREF(kwonly_sig);
6028 : : }
6029 : :
6030 : : static int
6031 : 18 : positional_only_passed_as_keyword(PyThreadState *tstate, PyCodeObject *co,
6032 : : Py_ssize_t kwcount, PyObject* kwnames,
6033 : : PyObject *qualname)
6034 : : {
6035 : 18 : int posonly_conflicts = 0;
6036 : 18 : PyObject* posonly_names = PyList_New(0);
6037 : :
6038 [ + + ]: 47 : for(int k=0; k < co->co_posonlyargcount; k++){
6039 : 29 : PyObject* posonly_name = PyTuple_GET_ITEM(co->co_localsplusnames, k);
6040 : :
6041 [ + + ]: 77 : for (int k2=0; k2<kwcount; k2++){
6042 : : /* Compare the pointers first and fallback to PyObject_RichCompareBool*/
6043 : 48 : PyObject* kwname = PyTuple_GET_ITEM(kwnames, k2);
6044 [ + + ]: 48 : if (kwname == posonly_name){
6045 [ - + ]: 19 : if(PyList_Append(posonly_names, kwname) != 0) {
6046 : 0 : goto fail;
6047 : : }
6048 : 19 : posonly_conflicts++;
6049 : 19 : continue;
6050 : : }
6051 : :
6052 : 29 : int cmp = PyObject_RichCompareBool(posonly_name, kwname, Py_EQ);
6053 : :
6054 [ - + ]: 29 : if ( cmp > 0) {
6055 [ # # ]: 0 : if(PyList_Append(posonly_names, kwname) != 0) {
6056 : 0 : goto fail;
6057 : : }
6058 : 0 : posonly_conflicts++;
6059 [ - + ]: 29 : } else if (cmp < 0) {
6060 : 0 : goto fail;
6061 : : }
6062 : :
6063 : : }
6064 : : }
6065 [ + + ]: 18 : if (posonly_conflicts) {
6066 : 17 : PyObject* comma = PyUnicode_FromString(", ");
6067 [ - + ]: 17 : if (comma == NULL) {
6068 : 0 : goto fail;
6069 : : }
6070 : 17 : PyObject* error_names = PyUnicode_Join(comma, posonly_names);
6071 [ + - ]: 17 : Py_DECREF(comma);
6072 [ - + ]: 17 : if (error_names == NULL) {
6073 : 0 : goto fail;
6074 : : }
6075 : 17 : _PyErr_Format(tstate, PyExc_TypeError,
6076 : : "%U() got some positional-only arguments passed"
6077 : : " as keyword arguments: '%U'",
6078 : : qualname, error_names);
6079 [ + + ]: 17 : Py_DECREF(error_names);
6080 : 17 : goto fail;
6081 : : }
6082 : :
6083 [ + - ]: 1 : Py_DECREF(posonly_names);
6084 : 1 : return 0;
6085 : :
6086 : 17 : fail:
6087 [ + - + - ]: 17 : Py_XDECREF(posonly_names);
6088 : 17 : return 1;
6089 : :
6090 : : }
6091 : :
6092 : :
6093 : : static inline unsigned char *
6094 : 3593077 : scan_back_to_entry_start(unsigned char *p) {
6095 [ + + ]: 11314716 : for (; (p[0]&128) == 0; p--);
6096 : 3593077 : return p;
6097 : : }
6098 : :
6099 : : static inline unsigned char *
6100 : 4057011 : skip_to_next_entry(unsigned char *p, unsigned char *end) {
6101 [ + + + + ]: 15975911 : while (p < end && ((p[0] & 128) == 0)) {
6102 : 11918900 : p++;
6103 : : }
6104 : 4057011 : return p;
6105 : : }
6106 : :
6107 : :
6108 : : #define MAX_LINEAR_SEARCH 40
6109 : :
6110 : : static int
6111 : 5973257 : get_exception_handler(PyCodeObject *code, int index, int *level, int *handler, int *lasti)
6112 : : {
6113 : 5973257 : unsigned char *start = (unsigned char *)PyBytes_AS_STRING(code->co_exceptiontable);
6114 : 5973257 : unsigned char *end = start + PyBytes_GET_SIZE(code->co_exceptiontable);
6115 : : /* Invariants:
6116 : : * start_table == end_table OR
6117 : : * start_table points to a legal entry and end_table points
6118 : : * beyond the table or to a legal entry that is after index.
6119 : : */
6120 [ + + ]: 5973257 : if (end - start > MAX_LINEAR_SEARCH) {
6121 : : int offset;
6122 : 3023852 : parse_varint(start, &offset);
6123 [ + + ]: 3023852 : if (offset > index) {
6124 : 5230 : return 0;
6125 : : }
6126 : : do {
6127 : 3593077 : unsigned char * mid = start + ((end-start)>>1);
6128 : 3593077 : mid = scan_back_to_entry_start(mid);
6129 : 3593077 : parse_varint(mid, &offset);
6130 [ + + ]: 3593077 : if (offset > index) {
6131 : 2860833 : end = mid;
6132 : : }
6133 : : else {
6134 : 732244 : start = mid;
6135 : : }
6136 : :
6137 [ + + ]: 3593077 : } while (end - start > MAX_LINEAR_SEARCH);
6138 : : }
6139 : 5968027 : unsigned char *scan = start;
6140 [ + + ]: 10025038 : while (scan < end) {
6141 : : int start_offset, size;
6142 : 8519605 : scan = parse_varint(scan, &start_offset);
6143 [ + + ]: 8519605 : if (start_offset > index) {
6144 : 169592 : break;
6145 : : }
6146 : 8350013 : scan = parse_varint(scan, &size);
6147 [ + + ]: 8350013 : if (start_offset + size > index) {
6148 : 4293002 : scan = parse_varint(scan, handler);
6149 : : int depth_and_lasti;
6150 : 4293002 : parse_varint(scan, &depth_and_lasti);
6151 : 4293002 : *level = depth_and_lasti >> 1;
6152 : 4293002 : *lasti = depth_and_lasti & 1;
6153 : 4293002 : return 1;
6154 : : }
6155 : 4057011 : scan = skip_to_next_entry(scan, end);
6156 : : }
6157 : 1675025 : return 0;
6158 : : }
6159 : :
6160 : : static int
6161 : 119570202 : initialize_locals(PyThreadState *tstate, PyFunctionObject *func,
6162 : : PyObject **localsplus, PyObject *const *args,
6163 : : Py_ssize_t argcount, PyObject *kwnames)
6164 : : {
6165 : 119570202 : PyCodeObject *co = (PyCodeObject*)func->func_code;
6166 : 119570202 : const Py_ssize_t total_args = co->co_argcount + co->co_kwonlyargcount;
6167 : :
6168 : : /* Create a dictionary for keyword parameters (**kwags) */
6169 : : PyObject *kwdict;
6170 : : Py_ssize_t i;
6171 [ + + ]: 119570202 : if (co->co_flags & CO_VARKEYWORDS) {
6172 : 5265723 : kwdict = PyDict_New();
6173 [ - + ]: 5265723 : if (kwdict == NULL) {
6174 : 0 : goto fail_pre_positional;
6175 : : }
6176 : 5265723 : i = total_args;
6177 [ + + ]: 5265723 : if (co->co_flags & CO_VARARGS) {
6178 : 4356471 : i++;
6179 : : }
6180 : : assert(localsplus[i] == NULL);
6181 : 5265723 : localsplus[i] = kwdict;
6182 : : }
6183 : : else {
6184 : 114304479 : kwdict = NULL;
6185 : : }
6186 : :
6187 : : /* Copy all positional arguments into local variables */
6188 : : Py_ssize_t j, n;
6189 [ + + ]: 119570202 : if (argcount > co->co_argcount) {
6190 : 18135693 : n = co->co_argcount;
6191 : : }
6192 : : else {
6193 : 101434509 : n = argcount;
6194 : : }
6195 [ + + ]: 369889403 : for (j = 0; j < n; j++) {
6196 : 250319201 : PyObject *x = args[j];
6197 : : assert(localsplus[j] == NULL);
6198 : 250319201 : localsplus[j] = x;
6199 : : }
6200 : :
6201 : : /* Pack other positional arguments into the *args argument */
6202 [ + + ]: 119570202 : if (co->co_flags & CO_VARARGS) {
6203 : 19134829 : PyObject *u = NULL;
6204 : 19134829 : u = _PyTuple_FromArraySteal(args + n, argcount - n);
6205 [ - + ]: 19134829 : if (u == NULL) {
6206 : 0 : goto fail_post_positional;
6207 : : }
6208 : : assert(localsplus[total_args] == NULL);
6209 : 19134829 : localsplus[total_args] = u;
6210 : : }
6211 [ + + ]: 100435373 : else if (argcount > n) {
6212 : : /* Too many postional args. Error is reported later */
6213 [ + + ]: 2687 : for (j = n; j < argcount; j++) {
6214 [ + + ]: 1371 : Py_DECREF(args[j]);
6215 : : }
6216 : : }
6217 : :
6218 : : /* Handle keyword arguments */
6219 [ + + ]: 119570202 : if (kwnames != NULL) {
6220 : 15557398 : Py_ssize_t kwcount = PyTuple_GET_SIZE(kwnames);
6221 [ + + ]: 34672861 : for (i = 0; i < kwcount; i++) {
6222 : : PyObject **co_varnames;
6223 : 19115701 : PyObject *keyword = PyTuple_GET_ITEM(kwnames, i);
6224 : 19115701 : PyObject *value = args[i+argcount];
6225 : : Py_ssize_t j;
6226 : :
6227 [ + - - + ]: 19115701 : if (keyword == NULL || !PyUnicode_Check(keyword)) {
6228 : 0 : _PyErr_Format(tstate, PyExc_TypeError,
6229 : : "%U() keywords must be strings",
6230 : : func->func_qualname);
6231 : 0 : goto kw_fail;
6232 : : }
6233 : :
6234 : : /* Speed hack: do raw pointer compares. As names are
6235 : : normally interned this should almost always hit. */
6236 : 19115701 : co_varnames = ((PyTupleObject *)(co->co_localsplusnames))->ob_item;
6237 [ + + ]: 71827412 : for (j = co->co_posonlyargcount; j < total_args; j++) {
6238 : 69730410 : PyObject *varname = co_varnames[j];
6239 [ + + ]: 69730410 : if (varname == keyword) {
6240 : 17018699 : goto kw_found;
6241 : : }
6242 : : }
6243 : :
6244 : : /* Slow fallback, just in case */
6245 [ + + ]: 4061178 : for (j = co->co_posonlyargcount; j < total_args; j++) {
6246 : 1996526 : PyObject *varname = co_varnames[j];
6247 : 1996526 : int cmp = PyObject_RichCompareBool( keyword, varname, Py_EQ);
6248 [ + + ]: 1996526 : if (cmp > 0) {
6249 : 32350 : goto kw_found;
6250 : : }
6251 [ - + ]: 1964176 : else if (cmp < 0) {
6252 : 0 : goto kw_fail;
6253 : : }
6254 : : }
6255 : :
6256 : : assert(j >= total_args);
6257 [ + + ]: 2064652 : if (kwdict == NULL) {
6258 : :
6259 [ + + ]: 177 : if (co->co_posonlyargcount
6260 [ + + ]: 18 : && positional_only_passed_as_keyword(tstate, co,
6261 : : kwcount, kwnames,
6262 : : func->func_qualname))
6263 : : {
6264 : 17 : goto kw_fail;
6265 : : }
6266 : :
6267 : 160 : _PyErr_Format(tstate, PyExc_TypeError,
6268 : : "%U() got an unexpected keyword argument '%S'",
6269 : : func->func_qualname, keyword);
6270 : 160 : goto kw_fail;
6271 : : }
6272 : :
6273 [ - + ]: 2064475 : if (PyDict_SetItem(kwdict, keyword, value) == -1) {
6274 : 0 : goto kw_fail;
6275 : : }
6276 [ - + ]: 2064475 : Py_DECREF(value);
6277 : 2064475 : continue;
6278 : :
6279 : 238 : kw_fail:
6280 [ + + ]: 624 : for (;i < kwcount; i++) {
6281 : 386 : PyObject *value = args[i+argcount];
6282 [ - + ]: 386 : Py_DECREF(value);
6283 : : }
6284 : 238 : goto fail_post_args;
6285 : :
6286 : 17051049 : kw_found:
6287 [ + + ]: 17051049 : if (localsplus[j] != NULL) {
6288 : 61 : _PyErr_Format(tstate, PyExc_TypeError,
6289 : : "%U() got multiple values for argument '%S'",
6290 : : func->func_qualname, keyword);
6291 : 61 : goto kw_fail;
6292 : : }
6293 : 17050988 : localsplus[j] = value;
6294 : : }
6295 : : }
6296 : :
6297 : : /* Check the number of positional arguments */
6298 [ + + + + ]: 119569964 : if ((argcount > co->co_argcount) && !(co->co_flags & CO_VARARGS)) {
6299 : 1294 : too_many_positional(tstate, co, argcount, func->func_defaults, localsplus,
6300 : : func->func_qualname);
6301 : 1294 : goto fail_post_args;
6302 : : }
6303 : :
6304 : : /* Add missing positional arguments (copy default values from defs) */
6305 [ + + ]: 119568670 : if (argcount < co->co_argcount) {
6306 [ + + ]: 18833630 : Py_ssize_t defcount = func->func_defaults == NULL ? 0 : PyTuple_GET_SIZE(func->func_defaults);
6307 : 18833630 : Py_ssize_t m = co->co_argcount - defcount;
6308 : 18833630 : Py_ssize_t missing = 0;
6309 [ + + ]: 19232523 : for (i = argcount; i < m; i++) {
6310 [ + + ]: 398893 : if (localsplus[i] == NULL) {
6311 : 711 : missing++;
6312 : : }
6313 : : }
6314 [ + + ]: 18833630 : if (missing) {
6315 : 621 : missing_arguments(tstate, co, missing, defcount, localsplus,
6316 : : func->func_qualname);
6317 : 621 : goto fail_post_args;
6318 : : }
6319 [ + + ]: 18833009 : if (n > m)
6320 : 2307658 : i = n - m;
6321 : : else
6322 : 16525351 : i = 0;
6323 [ + + ]: 18833009 : if (defcount) {
6324 : 18761187 : PyObject **defs = &PyTuple_GET_ITEM(func->func_defaults, 0);
6325 [ + + ]: 45400549 : for (; i < defcount; i++) {
6326 [ + + ]: 26639362 : if (localsplus[m+i] == NULL) {
6327 : 15138831 : PyObject *def = defs[i];
6328 : 15138831 : Py_INCREF(def);
6329 : 15138831 : localsplus[m+i] = def;
6330 : : }
6331 : : }
6332 : : }
6333 : : }
6334 : :
6335 : : /* Add missing keyword arguments (copy default values from kwdefs) */
6336 [ + + ]: 119568049 : if (co->co_kwonlyargcount > 0) {
6337 : 6333138 : Py_ssize_t missing = 0;
6338 [ + + ]: 17314500 : for (i = co->co_argcount; i < total_args; i++) {
6339 [ + + ]: 10981362 : if (localsplus[i] != NULL)
6340 : 5152245 : continue;
6341 : 5829117 : PyObject *varname = PyTuple_GET_ITEM(co->co_localsplusnames, i);
6342 [ + + ]: 5829117 : if (func->func_kwdefaults != NULL) {
6343 : 5829107 : PyObject *def = PyDict_GetItemWithError(func->func_kwdefaults, varname);
6344 [ + + ]: 5829107 : if (def) {
6345 : 5829094 : Py_INCREF(def);
6346 : 5829094 : localsplus[i] = def;
6347 : 5829094 : continue;
6348 : : }
6349 [ - + ]: 13 : else if (_PyErr_Occurred(tstate)) {
6350 : 0 : goto fail_post_args;
6351 : : }
6352 : : }
6353 : 23 : missing++;
6354 : : }
6355 [ + + ]: 6333138 : if (missing) {
6356 : 18 : missing_arguments(tstate, co, missing, -1, localsplus,
6357 : : func->func_qualname);
6358 : 18 : goto fail_post_args;
6359 : : }
6360 : : }
6361 : 119568031 : return 0;
6362 : :
6363 : 0 : fail_pre_positional:
6364 [ # # ]: 0 : for (j = 0; j < argcount; j++) {
6365 [ # # ]: 0 : Py_DECREF(args[j]);
6366 : : }
6367 : : /* fall through */
6368 : 0 : fail_post_positional:
6369 [ # # ]: 0 : if (kwnames) {
6370 : 0 : Py_ssize_t kwcount = PyTuple_GET_SIZE(kwnames);
6371 [ # # ]: 0 : for (j = argcount; j < argcount+kwcount; j++) {
6372 [ # # ]: 0 : Py_DECREF(args[j]);
6373 : : }
6374 : : }
6375 : : /* fall through */
6376 : 0 : fail_post_args:
6377 : 2171 : return -1;
6378 : : }
6379 : :
6380 : : /* Consumes references to func, locals and all the args */
6381 : : static _PyInterpreterFrame *
6382 : 119570202 : _PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,
6383 : : PyObject *locals, PyObject* const* args,
6384 : : size_t argcount, PyObject *kwnames)
6385 : : {
6386 : 119570202 : PyCodeObject * code = (PyCodeObject *)func->func_code;
6387 : : CALL_STAT_INC(frames_pushed);
6388 : 119570202 : _PyInterpreterFrame *frame = _PyThreadState_PushFrame(tstate, code->co_framesize);
6389 [ - + ]: 119570202 : if (frame == NULL) {
6390 : 0 : goto fail;
6391 : : }
6392 : 119570202 : _PyFrame_InitializeSpecials(frame, func, locals, code);
6393 : 119570202 : PyObject **localsarray = &frame->localsplus[0];
6394 [ + + ]: 590182329 : for (int i = 0; i < code->co_nlocalsplus; i++) {
6395 : 470612127 : localsarray[i] = NULL;
6396 : : }
6397 [ + + ]: 119570202 : if (initialize_locals(tstate, func, localsarray, args, argcount, kwnames)) {
6398 : : assert(frame->owner != FRAME_OWNED_BY_GENERATOR);
6399 : 2171 : _PyEvalFrameClearAndPop(tstate, frame);
6400 : 2171 : return NULL;
6401 : : }
6402 : 119568031 : return frame;
6403 : 0 : fail:
6404 : : /* Consume the references */
6405 [ # # ]: 0 : for (size_t i = 0; i < argcount; i++) {
6406 [ # # ]: 0 : Py_DECREF(args[i]);
6407 : : }
6408 [ # # ]: 0 : if (kwnames) {
6409 : 0 : Py_ssize_t kwcount = PyTuple_GET_SIZE(kwnames);
6410 [ # # ]: 0 : for (Py_ssize_t i = 0; i < kwcount; i++) {
6411 [ # # ]: 0 : Py_DECREF(args[i+argcount]);
6412 : : }
6413 : : }
6414 : : PyErr_NoMemory();
6415 : 0 : return NULL;
6416 : : }
6417 : :
6418 : : static void
6419 : 254050863 : _PyEvalFrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame * frame)
6420 : : {
6421 : : // Make sure that this is, indeed, the top frame. We can't check this in
6422 : : // _PyThreadState_PopFrame, since f_code is already cleared at that point:
6423 : : assert((PyObject **)frame + frame->f_code->co_framesize ==
6424 : : tstate->datastack_top);
6425 : 254050863 : tstate->recursion_remaining--;
6426 : : assert(frame->frame_obj == NULL || frame->frame_obj->f_frame == frame);
6427 : : assert(frame->owner == FRAME_OWNED_BY_THREAD);
6428 : 254050863 : _PyFrame_Clear(frame);
6429 : 254050863 : tstate->recursion_remaining++;
6430 : 254050863 : _PyThreadState_PopFrame(tstate, frame);
6431 : 254050863 : }
6432 : :
6433 : : PyObject *
6434 : 70949635 : _PyEval_Vector(PyThreadState *tstate, PyFunctionObject *func,
6435 : : PyObject *locals,
6436 : : PyObject* const* args, size_t argcount,
6437 : : PyObject *kwnames)
6438 : : {
6439 : : /* _PyEvalFramePushAndInit consumes the references
6440 : : * to func, locals and all its arguments */
6441 : 70949635 : Py_INCREF(func);
6442 : 70949635 : Py_XINCREF(locals);
6443 [ + + ]: 247359024 : for (size_t i = 0; i < argcount; i++) {
6444 : 176409389 : Py_INCREF(args[i]);
6445 : : }
6446 [ + + ]: 70949635 : if (kwnames) {
6447 : 3424960 : Py_ssize_t kwcount = PyTuple_GET_SIZE(kwnames);
6448 [ + + ]: 8566051 : for (Py_ssize_t i = 0; i < kwcount; i++) {
6449 : 5141091 : Py_INCREF(args[i+argcount]);
6450 : : }
6451 : : }
6452 : 70949635 : _PyInterpreterFrame *frame = _PyEvalFramePushAndInit(
6453 : : tstate, func, locals, args, argcount, kwnames);
6454 [ + + ]: 70949635 : if (frame == NULL) {
6455 : 859 : return NULL;
6456 : : }
6457 : : EVAL_CALL_STAT_INC(EVAL_CALL_VECTOR);
6458 : 70948776 : PyObject *retval = _PyEval_EvalFrame(tstate, frame, 0);
6459 : : assert(
6460 : : _PyFrame_GetStackPointer(frame) == _PyFrame_Stackbase(frame) ||
6461 : : _PyFrame_GetStackPointer(frame) == frame->localsplus
6462 : : );
6463 : 70948489 : _PyEvalFrameClearAndPop(tstate, frame);
6464 : 70948489 : return retval;
6465 : : }
6466 : :
6467 : : /* Legacy API */
6468 : : PyObject *
6469 : 2 : PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
6470 : : PyObject *const *args, int argcount,
6471 : : PyObject *const *kws, int kwcount,
6472 : : PyObject *const *defs, int defcount,
6473 : : PyObject *kwdefs, PyObject *closure)
6474 : : {
6475 : 2 : PyThreadState *tstate = _PyThreadState_GET();
6476 : 2 : PyObject *res = NULL;
6477 : 2 : PyObject *defaults = _PyTuple_FromArray(defs, defcount);
6478 [ - + ]: 2 : if (defaults == NULL) {
6479 : 0 : return NULL;
6480 : : }
6481 : 2 : PyObject *builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref
6482 [ - + ]: 2 : if (builtins == NULL) {
6483 [ # # ]: 0 : Py_DECREF(defaults);
6484 : 0 : return NULL;
6485 : : }
6486 [ - + ]: 2 : if (locals == NULL) {
6487 : 0 : locals = globals;
6488 : : }
6489 : 2 : PyObject *kwnames = NULL;
6490 : : PyObject *const *allargs;
6491 : 2 : PyObject **newargs = NULL;
6492 : 2 : PyFunctionObject *func = NULL;
6493 [ + - ]: 2 : if (kwcount == 0) {
6494 : 2 : allargs = args;
6495 : : }
6496 : : else {
6497 : 0 : kwnames = PyTuple_New(kwcount);
6498 [ # # ]: 0 : if (kwnames == NULL) {
6499 : 0 : goto fail;
6500 : : }
6501 : 0 : newargs = PyMem_Malloc(sizeof(PyObject *)*(kwcount+argcount));
6502 [ # # ]: 0 : if (newargs == NULL) {
6503 : 0 : goto fail;
6504 : : }
6505 [ # # ]: 0 : for (int i = 0; i < argcount; i++) {
6506 : 0 : newargs[i] = args[i];
6507 : : }
6508 [ # # ]: 0 : for (int i = 0; i < kwcount; i++) {
6509 : 0 : Py_INCREF(kws[2*i]);
6510 : 0 : PyTuple_SET_ITEM(kwnames, i, kws[2*i]);
6511 : 0 : newargs[argcount+i] = kws[2*i+1];
6512 : : }
6513 : 0 : allargs = newargs;
6514 : : }
6515 [ - + ]: 2 : for (int i = 0; i < kwcount; i++) {
6516 : 0 : Py_INCREF(kws[2*i]);
6517 : 0 : PyTuple_SET_ITEM(kwnames, i, kws[2*i]);
6518 : : }
6519 : 2 : PyFrameConstructor constr = {
6520 : : .fc_globals = globals,
6521 : : .fc_builtins = builtins,
6522 : 2 : .fc_name = ((PyCodeObject *)_co)->co_name,
6523 : 2 : .fc_qualname = ((PyCodeObject *)_co)->co_name,
6524 : : .fc_code = _co,
6525 : : .fc_defaults = defaults,
6526 : : .fc_kwdefaults = kwdefs,
6527 : : .fc_closure = closure
6528 : : };
6529 : 2 : func = _PyFunction_FromConstructor(&constr);
6530 [ - + ]: 2 : if (func == NULL) {
6531 : 0 : goto fail;
6532 : : }
6533 : : EVAL_CALL_STAT_INC(EVAL_CALL_LEGACY);
6534 : 2 : res = _PyEval_Vector(tstate, func, locals,
6535 : : allargs, argcount,
6536 : : kwnames);
6537 : 2 : fail:
6538 [ + - + - ]: 2 : Py_XDECREF(func);
6539 [ - + - - ]: 2 : Py_XDECREF(kwnames);
6540 : 2 : PyMem_Free(newargs);
6541 [ - + ]: 2 : Py_DECREF(defaults);
6542 : 2 : return res;
6543 : : }
6544 : :
6545 : :
6546 : : /* Logic for the raise statement (too complicated for inlining).
6547 : : This *consumes* a reference count to each of its arguments. */
6548 : : static int
6549 : 355812 : do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause)
6550 : : {
6551 : 355812 : PyObject *type = NULL, *value = NULL;
6552 : :
6553 [ + + ]: 355812 : if (exc == NULL) {
6554 : : /* Reraise */
6555 : 14062 : _PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate);
6556 : 14062 : value = exc_info->exc_value;
6557 [ + + + + ]: 14062 : if (Py_IsNone(value) || value == NULL) {
6558 : 2 : _PyErr_SetString(tstate, PyExc_RuntimeError,
6559 : : "No active exception to reraise");
6560 : 2 : return 0;
6561 : : }
6562 : : assert(PyExceptionInstance_Check(value));
6563 : 14060 : type = PyExceptionInstance_Class(value);
6564 : 14060 : Py_XINCREF(type);
6565 : 14060 : Py_XINCREF(value);
6566 : 14060 : PyObject *tb = PyException_GetTraceback(value); /* new ref */
6567 : 14060 : _PyErr_Restore(tstate, type, value, tb);
6568 : 14060 : return 1;
6569 : : }
6570 : :
6571 : : /* We support the following forms of raise:
6572 : : raise
6573 : : raise <instance>
6574 : : raise <type> */
6575 : :
6576 [ + + + + ]: 341750 : if (PyExceptionClass_Check(exc)) {
6577 : 29298 : type = exc;
6578 : 29298 : value = _PyObject_CallNoArgs(exc);
6579 [ + + ]: 29298 : if (value == NULL)
6580 : 2 : goto raise_error;
6581 [ + + ]: 29296 : if (!PyExceptionInstance_Check(value)) {
6582 : 1 : _PyErr_Format(tstate, PyExc_TypeError,
6583 : : "calling %R should have returned an instance of "
6584 : : "BaseException, not %R",
6585 : : type, Py_TYPE(value));
6586 : 1 : goto raise_error;
6587 : : }
6588 : : }
6589 [ + + ]: 312452 : else if (PyExceptionInstance_Check(exc)) {
6590 : 312447 : value = exc;
6591 : 312447 : type = PyExceptionInstance_Class(exc);
6592 : 312447 : Py_INCREF(type);
6593 : : }
6594 : : else {
6595 : : /* Not something you can raise. You get an exception
6596 : : anyway, just not what you specified :-) */
6597 [ + + ]: 5 : Py_DECREF(exc);
6598 : 5 : _PyErr_SetString(tstate, PyExc_TypeError,
6599 : : "exceptions must derive from BaseException");
6600 : 5 : goto raise_error;
6601 : : }
6602 : :
6603 : : assert(type != NULL);
6604 : : assert(value != NULL);
6605 : :
6606 [ + + ]: 341742 : if (cause) {
6607 : : PyObject *fixed_cause;
6608 [ + + + - ]: 68009 : if (PyExceptionClass_Check(cause)) {
6609 : 3 : fixed_cause = _PyObject_CallNoArgs(cause);
6610 [ + + ]: 3 : if (fixed_cause == NULL)
6611 : 1 : goto raise_error;
6612 [ - + ]: 2 : Py_DECREF(cause);
6613 : : }
6614 [ + + ]: 68006 : else if (PyExceptionInstance_Check(cause)) {
6615 : 1661 : fixed_cause = cause;
6616 : : }
6617 [ + + ]: 66345 : else if (Py_IsNone(cause)) {
6618 [ - + ]: 66344 : Py_DECREF(cause);
6619 : 66344 : fixed_cause = NULL;
6620 : : }
6621 : : else {
6622 : 1 : _PyErr_SetString(tstate, PyExc_TypeError,
6623 : : "exception causes must derive from "
6624 : : "BaseException");
6625 : 1 : goto raise_error;
6626 : : }
6627 : 68007 : PyException_SetCause(value, fixed_cause);
6628 : : }
6629 : :
6630 : 341740 : _PyErr_SetObject(tstate, type, value);
6631 : : /* _PyErr_SetObject incref's its arguments */
6632 [ - + ]: 341740 : Py_DECREF(value);
6633 [ - + ]: 341740 : Py_DECREF(type);
6634 : 341740 : return 0;
6635 : :
6636 : 10 : raise_error:
6637 [ + + + - ]: 10 : Py_XDECREF(value);
6638 [ + + - + ]: 10 : Py_XDECREF(type);
6639 [ + + - + ]: 10 : Py_XDECREF(cause);
6640 : 10 : return 0;
6641 : : }
6642 : :
6643 : : /* Logic for matching an exception in an except* clause (too
6644 : : complicated for inlining).
6645 : : */
6646 : :
6647 : : static int
6648 : 175 : exception_group_match(PyObject* exc_value, PyObject *match_type,
6649 : : PyObject **match, PyObject **rest)
6650 : : {
6651 [ + + ]: 175 : if (Py_IsNone(exc_value)) {
6652 : 2 : *match = Py_NewRef(Py_None);
6653 : 2 : *rest = Py_NewRef(Py_None);
6654 : 2 : return 0;
6655 : : }
6656 : : assert(PyExceptionInstance_Check(exc_value));
6657 : :
6658 [ + + ]: 173 : if (PyErr_GivenExceptionMatches(exc_value, match_type)) {
6659 : : /* Full match of exc itself */
6660 : 56 : bool is_eg = _PyBaseExceptionGroup_Check(exc_value);
6661 [ + + ]: 56 : if (is_eg) {
6662 : 18 : *match = Py_NewRef(exc_value);
6663 : : }
6664 : : else {
6665 : : /* naked exception - wrap it */
6666 : 38 : PyObject *excs = PyTuple_Pack(1, exc_value);
6667 [ - + ]: 38 : if (excs == NULL) {
6668 : 0 : return -1;
6669 : : }
6670 : 38 : PyObject *wrapped = _PyExc_CreateExceptionGroup("", excs);
6671 [ - + ]: 38 : Py_DECREF(excs);
6672 [ - + ]: 38 : if (wrapped == NULL) {
6673 : 0 : return -1;
6674 : : }
6675 : 38 : *match = wrapped;
6676 : : }
6677 : 56 : *rest = Py_NewRef(Py_None);
6678 : 56 : return 0;
6679 : : }
6680 : :
6681 : : /* exc_value does not match match_type.
6682 : : * Check for partial match if it's an exception group.
6683 : : */
6684 [ + + ]: 117 : if (_PyBaseExceptionGroup_Check(exc_value)) {
6685 : 101 : PyObject *pair = PyObject_CallMethod(exc_value, "split", "(O)",
6686 : : match_type);
6687 [ - + ]: 101 : if (pair == NULL) {
6688 : 0 : return -1;
6689 : : }
6690 : : assert(PyTuple_CheckExact(pair));
6691 : : assert(PyTuple_GET_SIZE(pair) == 2);
6692 : 101 : *match = Py_NewRef(PyTuple_GET_ITEM(pair, 0));
6693 : 101 : *rest = Py_NewRef(PyTuple_GET_ITEM(pair, 1));
6694 [ + - ]: 101 : Py_DECREF(pair);
6695 : 101 : return 0;
6696 : : }
6697 : : /* no match */
6698 : 16 : *match = Py_NewRef(Py_None);
6699 : 16 : *rest = Py_NewRef(Py_None);
6700 : 16 : return 0;
6701 : : }
6702 : :
6703 : : /* Iterate v argcnt times and store the results on the stack (via decreasing
6704 : : sp). Return 1 for success, 0 if error.
6705 : :
6706 : : If argcntafter == -1, do a simple unpack. If it is >= 0, do an unpack
6707 : : with a variable target.
6708 : : */
6709 : :
6710 : : static int
6711 : 3812520 : unpack_iterable(PyThreadState *tstate, PyObject *v,
6712 : : int argcnt, int argcntafter, PyObject **sp)
6713 : : {
6714 : 3812520 : int i = 0, j = 0;
6715 : 3812520 : Py_ssize_t ll = 0;
6716 : : PyObject *it; /* iter(v) */
6717 : : PyObject *w;
6718 : 3812520 : PyObject *l = NULL; /* variable list */
6719 : :
6720 : : assert(v != NULL);
6721 : :
6722 : 3812520 : it = PyObject_GetIter(v);
6723 [ + + ]: 3812520 : if (it == NULL) {
6724 [ + + ]: 12 : if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) &&
6725 [ + - + - ]: 9 : Py_TYPE(v)->tp_iter == NULL && !PySequence_Check(v))
6726 : : {
6727 : 9 : _PyErr_Format(tstate, PyExc_TypeError,
6728 : : "cannot unpack non-iterable %.200s object",
6729 : 9 : Py_TYPE(v)->tp_name);
6730 : : }
6731 : 12 : return 0;
6732 : : }
6733 : :
6734 [ + + ]: 19636306 : for (; i < argcnt; i++) {
6735 : 15825158 : w = PyIter_Next(it);
6736 [ + + ]: 15825158 : if (w == NULL) {
6737 : : /* Iterator done, via error or exhaustion. */
6738 [ + + ]: 1360 : if (!_PyErr_Occurred(tstate)) {
6739 [ + + ]: 1338 : if (argcntafter == -1) {
6740 : 1337 : _PyErr_Format(tstate, PyExc_ValueError,
6741 : : "not enough values to unpack "
6742 : : "(expected %d, got %d)",
6743 : : argcnt, i);
6744 : : }
6745 : : else {
6746 : 1 : _PyErr_Format(tstate, PyExc_ValueError,
6747 : : "not enough values to unpack "
6748 : : "(expected at least %d, got %d)",
6749 : : argcnt + argcntafter, i);
6750 : : }
6751 : : }
6752 : 1360 : goto Error;
6753 : : }
6754 : 15823798 : *--sp = w;
6755 : : }
6756 : :
6757 [ + + ]: 3811148 : if (argcntafter == -1) {
6758 : : /* We better have exhausted the iterator now. */
6759 : 3707488 : w = PyIter_Next(it);
6760 [ + + ]: 3707488 : if (w == NULL) {
6761 [ + + ]: 3707433 : if (_PyErr_Occurred(tstate))
6762 : 1 : goto Error;
6763 [ + + ]: 3707432 : Py_DECREF(it);
6764 : 3707432 : return 1;
6765 : : }
6766 [ - + ]: 55 : Py_DECREF(w);
6767 : 55 : _PyErr_Format(tstate, PyExc_ValueError,
6768 : : "too many values to unpack (expected %d)",
6769 : : argcnt);
6770 : 55 : goto Error;
6771 : : }
6772 : :
6773 : 103660 : l = PySequence_List(it);
6774 [ + + ]: 103660 : if (l == NULL)
6775 : 1 : goto Error;
6776 : 103659 : *--sp = l;
6777 : 103659 : i++;
6778 : :
6779 : 103659 : ll = PyList_GET_SIZE(l);
6780 [ + + ]: 103659 : if (ll < argcntafter) {
6781 : 1 : _PyErr_Format(tstate, PyExc_ValueError,
6782 : : "not enough values to unpack (expected at least %d, got %zd)",
6783 : : argcnt + argcntafter, argcnt + ll);
6784 : 1 : goto Error;
6785 : : }
6786 : :
6787 : : /* Pop the "after-variable" args off the list. */
6788 [ + + ]: 103860 : for (j = argcntafter; j > 0; j--, i++) {
6789 : 202 : *--sp = PyList_GET_ITEM(l, ll - j);
6790 : : }
6791 : : /* Resize the list. */
6792 : 103658 : Py_SET_SIZE(l, ll - argcntafter);
6793 [ + - ]: 103658 : Py_DECREF(it);
6794 : 103658 : return 1;
6795 : :
6796 : 1418 : Error:
6797 [ + + ]: 2882 : for (; i > 0; i--, sp++)
6798 [ + + ]: 1464 : Py_DECREF(*sp);
6799 [ + - + + ]: 1418 : Py_XDECREF(it);
6800 : 1418 : return 0;
6801 : : }
6802 : :
6803 : : static void
6804 : 8791 : call_exc_trace(Py_tracefunc func, PyObject *self,
6805 : : PyThreadState *tstate,
6806 : : _PyInterpreterFrame *f)
6807 : : {
6808 : : PyObject *type, *value, *traceback, *orig_traceback, *arg;
6809 : : int err;
6810 : 8791 : _PyErr_Fetch(tstate, &type, &value, &orig_traceback);
6811 [ + + ]: 8791 : if (value == NULL) {
6812 : 1141 : value = Py_None;
6813 : 1141 : Py_INCREF(value);
6814 : : }
6815 : 8791 : _PyErr_NormalizeException(tstate, &type, &value, &orig_traceback);
6816 [ + + ]: 8791 : traceback = (orig_traceback != NULL) ? orig_traceback : Py_None;
6817 : 8791 : arg = PyTuple_Pack(3, type, value, traceback);
6818 [ - + ]: 8791 : if (arg == NULL) {
6819 : 0 : _PyErr_Restore(tstate, type, value, orig_traceback);
6820 : 0 : return;
6821 : : }
6822 : 8791 : err = call_trace(func, self, tstate, f, PyTrace_EXCEPTION, arg);
6823 [ + + ]: 8791 : Py_DECREF(arg);
6824 [ + + ]: 8791 : if (err == 0) {
6825 : 7789 : _PyErr_Restore(tstate, type, value, orig_traceback);
6826 : : }
6827 : : else {
6828 [ + - - + ]: 1002 : Py_XDECREF(type);
6829 [ + - - + ]: 1002 : Py_XDECREF(value);
6830 [ + - - + ]: 1002 : Py_XDECREF(orig_traceback);
6831 : : }
6832 : : }
6833 : :
6834 : : static int
6835 : 2611336 : call_trace_protected(Py_tracefunc func, PyObject *obj,
6836 : : PyThreadState *tstate, _PyInterpreterFrame *frame,
6837 : : int what, PyObject *arg)
6838 : : {
6839 : : PyObject *type, *value, *traceback;
6840 : : int err;
6841 : 2611336 : _PyErr_Fetch(tstate, &type, &value, &traceback);
6842 : 2611336 : err = call_trace(func, obj, tstate, frame, what, arg);
6843 [ + + ]: 2611336 : if (err == 0)
6844 : : {
6845 : 2609325 : _PyErr_Restore(tstate, type, value, traceback);
6846 : 2609325 : return 0;
6847 : : }
6848 : : else {
6849 [ + + - + ]: 2011 : Py_XDECREF(type);
6850 [ + + - + ]: 2011 : Py_XDECREF(value);
6851 [ + + - + ]: 2011 : Py_XDECREF(traceback);
6852 : 2011 : return -1;
6853 : : }
6854 : : }
6855 : :
6856 : : static void
6857 : 0 : initialize_trace_info(PyTraceInfo *trace_info, _PyInterpreterFrame *frame)
6858 : : {
6859 : 0 : PyCodeObject *code = frame->f_code;
6860 [ # # ]: 0 : if (trace_info->code != code) {
6861 : 0 : trace_info->code = code;
6862 : 0 : _PyCode_InitAddressRange(code, &trace_info->bounds);
6863 : : }
6864 : 0 : }
6865 : :
6866 : : void
6867 : 5929761 : PyThreadState_EnterTracing(PyThreadState *tstate)
6868 : : {
6869 : 5929761 : tstate->tracing++;
6870 : 5929761 : }
6871 : :
6872 : : void
6873 : 5929761 : PyThreadState_LeaveTracing(PyThreadState *tstate)
6874 : : {
6875 : 5929761 : tstate->tracing--;
6876 : 5929761 : }
6877 : :
6878 : : static int
6879 : 3911402 : call_trace(Py_tracefunc func, PyObject *obj,
6880 : : PyThreadState *tstate, _PyInterpreterFrame *frame,
6881 : : int what, PyObject *arg)
6882 : : {
6883 : : int result;
6884 [ + + ]: 3911402 : if (tstate->tracing) {
6885 : 2359859 : return 0;
6886 : : }
6887 : 1551543 : PyFrameObject *f = _PyFrame_GetFrameObject(frame);
6888 [ - + ]: 1551543 : if (f == NULL) {
6889 : 0 : return -1;
6890 : : }
6891 : 1551543 : int old_what = tstate->tracing_what;
6892 : 1551543 : tstate->tracing_what = what;
6893 : 1551543 : PyThreadState_EnterTracing(tstate);
6894 : : assert(_PyInterpreterFrame_LASTI(frame) >= 0);
6895 [ - + ]: 1551543 : if (_PyCode_InitLineArray(frame->f_code)) {
6896 : 0 : return -1;
6897 : : }
6898 : 1551543 : f->f_lineno = _PyCode_LineNumberFromArray(frame->f_code, _PyInterpreterFrame_LASTI(frame));
6899 : 1551543 : result = func(obj, f, what, arg);
6900 : 1551543 : f->f_lineno = 0;
6901 : 1551543 : PyThreadState_LeaveTracing(tstate);
6902 : 1551543 : tstate->tracing_what = old_what;
6903 : 1551543 : return result;
6904 : : }
6905 : :
6906 : : PyObject*
6907 : 2 : _PyEval_CallTracing(PyObject *func, PyObject *args)
6908 : : {
6909 : : // Save and disable tracing
6910 : 2 : PyThreadState *tstate = _PyThreadState_GET();
6911 : 2 : int save_tracing = tstate->tracing;
6912 : 2 : int save_use_tracing = tstate->cframe->use_tracing;
6913 : 2 : tstate->tracing = 0;
6914 : :
6915 : : // Call the tracing function
6916 : 2 : PyObject *result = PyObject_Call(func, args, NULL);
6917 : :
6918 : : // Restore tracing
6919 : 2 : tstate->tracing = save_tracing;
6920 : 2 : tstate->cframe->use_tracing = save_use_tracing;
6921 : 2 : return result;
6922 : : }
6923 : :
6924 : : /* See Objects/lnotab_notes.txt for a description of how tracing works. */
6925 : : static int
6926 : 5859013 : maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
6927 : : PyThreadState *tstate, _PyInterpreterFrame *frame, int instr_prev)
6928 : : {
6929 : 5859013 : int result = 0;
6930 : :
6931 : : /* If the last instruction falls at the start of a line or if it
6932 : : represents a jump backwards, update the frame's line number and
6933 : : then call the trace function if we're tracing source lines.
6934 : : */
6935 [ - + ]: 5859013 : if (_PyCode_InitLineArray(frame->f_code)) {
6936 : 0 : return -1;
6937 : : }
6938 : : int lastline;
6939 [ + + ]: 5859013 : if (instr_prev <= frame->f_code->_co_firsttraceable) {
6940 : 127822 : lastline = -1;
6941 : : }
6942 : : else {
6943 : 5731191 : lastline = _PyCode_LineNumberFromArray(frame->f_code, instr_prev);
6944 : : }
6945 : 5859013 : int line = _PyCode_LineNumberFromArray(frame->f_code, _PyInterpreterFrame_LASTI(frame));
6946 : 5859013 : PyFrameObject *f = _PyFrame_GetFrameObject(frame);
6947 [ - + ]: 5859013 : if (f == NULL) {
6948 : 0 : return -1;
6949 : : }
6950 [ + + + + ]: 5859013 : if (line != -1 && f->f_trace_lines) {
6951 : : /* Trace backward edges (except in 'yield from') or if line number has changed */
6952 [ + + ]: 10439063 : int trace = line != lastline ||
6953 [ + + ]: 4584341 : (_PyInterpreterFrame_LASTI(frame) < instr_prev &&
6954 : : // SEND has no quickened forms, so no need to use _PyOpcode_Deopt
6955 : : // here:
6956 [ + + ]: 3978 : _Py_OPCODE(*frame->prev_instr) != SEND);
6957 [ + + ]: 5854722 : if (trace) {
6958 : 1273565 : result = call_trace(func, obj, tstate, frame, PyTrace_LINE, Py_None);
6959 : : }
6960 : : }
6961 : : /* Always emit an opcode event if we're tracing all opcodes. */
6962 [ + + ]: 5859013 : if (f->f_trace_opcodes) {
6963 : 1391 : result = call_trace(func, obj, tstate, frame, PyTrace_OPCODE, Py_None);
6964 : : }
6965 : 5859013 : return result;
6966 : : }
6967 : :
6968 : : int
6969 : 170 : _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
6970 : : {
6971 : : assert(is_tstate_valid(tstate));
6972 : : /* The caller must hold the GIL */
6973 : : assert(PyGILState_Check());
6974 : :
6975 : : static int reentrant = 0;
6976 [ + + ]: 170 : if (reentrant) {
6977 : 2 : _PyErr_SetString(tstate, PyExc_RuntimeError, "Cannot install a profile function "
6978 : : "while another profile function is being installed");
6979 : 2 : reentrant = 0;
6980 : 2 : return -1;
6981 : : }
6982 : 168 : reentrant = 1;
6983 : :
6984 : : /* Call _PySys_Audit() in the context of the current thread state,
6985 : : even if tstate is not the current thread state. */
6986 : 168 : PyThreadState *current_tstate = _PyThreadState_GET();
6987 [ - + ]: 168 : if (_PySys_Audit(current_tstate, "sys.setprofile", NULL) < 0) {
6988 : 0 : reentrant = 0;
6989 : 0 : return -1;
6990 : : }
6991 : :
6992 : 168 : PyObject *profileobj = tstate->c_profileobj;
6993 : :
6994 : 168 : tstate->c_profilefunc = NULL;
6995 : 168 : tstate->c_profileobj = NULL;
6996 : : /* Must make sure that tracing is not ignored if 'profileobj' is freed */
6997 : 168 : _PyThreadState_UpdateTracingState(tstate);
6998 [ + + + + ]: 168 : Py_XDECREF(profileobj);
6999 : :
7000 : 168 : Py_XINCREF(arg);
7001 : 168 : tstate->c_profileobj = arg;
7002 : 168 : tstate->c_profilefunc = func;
7003 : :
7004 : : /* Flag that tracing or profiling is turned on */
7005 : 168 : _PyThreadState_UpdateTracingState(tstate);
7006 : 168 : reentrant = 0;
7007 : 168 : return 0;
7008 : : }
7009 : :
7010 : : void
7011 : 0 : PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
7012 : : {
7013 : 0 : PyThreadState *tstate = _PyThreadState_GET();
7014 [ # # ]: 0 : if (_PyEval_SetProfile(tstate, func, arg) < 0) {
7015 : : /* Log _PySys_Audit() error */
7016 : 0 : _PyErr_WriteUnraisableMsg("in PyEval_SetProfile", NULL);
7017 : : }
7018 : 0 : }
7019 : :
7020 : : int
7021 : 10896 : _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
7022 : : {
7023 : : assert(is_tstate_valid(tstate));
7024 : : /* The caller must hold the GIL */
7025 : : assert(PyGILState_Check());
7026 : :
7027 : : static int reentrant = 0;
7028 : :
7029 [ + + ]: 10896 : if (reentrant) {
7030 : 1 : _PyErr_SetString(tstate, PyExc_RuntimeError, "Cannot install a trace function "
7031 : : "while another trace function is being installed");
7032 : 1 : reentrant = 0;
7033 : 1 : return -1;
7034 : : }
7035 : 10895 : reentrant = 1;
7036 : :
7037 : : /* Call _PySys_Audit() in the context of the current thread state,
7038 : : even if tstate is not the current thread state. */
7039 : 10895 : PyThreadState *current_tstate = _PyThreadState_GET();
7040 [ - + ]: 10895 : if (_PySys_Audit(current_tstate, "sys.settrace", NULL) < 0) {
7041 : 0 : reentrant = 0;
7042 : 0 : return -1;
7043 : : }
7044 : :
7045 : 10895 : PyObject *traceobj = tstate->c_traceobj;
7046 : :
7047 : 10895 : tstate->c_tracefunc = NULL;
7048 : 10895 : tstate->c_traceobj = NULL;
7049 : : /* Must make sure that profiling is not ignored if 'traceobj' is freed */
7050 : 10895 : _PyThreadState_UpdateTracingState(tstate);
7051 : 10895 : Py_XINCREF(arg);
7052 [ + + + + ]: 10895 : Py_XDECREF(traceobj);
7053 : 10895 : tstate->c_traceobj = arg;
7054 : 10895 : tstate->c_tracefunc = func;
7055 : :
7056 : : /* Flag that tracing or profiling is turned on */
7057 : 10895 : _PyThreadState_UpdateTracingState(tstate);
7058 : :
7059 : 10895 : reentrant = 0;
7060 : 10895 : return 0;
7061 : : }
7062 : :
7063 : : void
7064 : 3 : PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
7065 : : {
7066 : 3 : PyThreadState *tstate = _PyThreadState_GET();
7067 [ - + ]: 3 : if (_PyEval_SetTrace(tstate, func, arg) < 0) {
7068 : : /* Log _PySys_Audit() error */
7069 : 0 : _PyErr_WriteUnraisableMsg("in PyEval_SetTrace", NULL);
7070 : : }
7071 : 3 : }
7072 : :
7073 : :
7074 : : int
7075 : 2478 : _PyEval_SetCoroutineOriginTrackingDepth(int depth)
7076 : : {
7077 : 2478 : PyThreadState *tstate = _PyThreadState_GET();
7078 [ + + ]: 2478 : if (depth < 0) {
7079 : 1 : _PyErr_SetString(tstate, PyExc_ValueError, "depth must be >= 0");
7080 : 1 : return -1;
7081 : : }
7082 : 2477 : tstate->coroutine_origin_tracking_depth = depth;
7083 : 2477 : return 0;
7084 : : }
7085 : :
7086 : :
7087 : : int
7088 : 1243 : _PyEval_GetCoroutineOriginTrackingDepth(void)
7089 : : {
7090 : 1243 : PyThreadState *tstate = _PyThreadState_GET();
7091 : 1243 : return tstate->coroutine_origin_tracking_depth;
7092 : : }
7093 : :
7094 : : int
7095 : 10326 : _PyEval_SetAsyncGenFirstiter(PyObject *firstiter)
7096 : : {
7097 : 10326 : PyThreadState *tstate = _PyThreadState_GET();
7098 : :
7099 [ - + ]: 10326 : if (_PySys_Audit(tstate, "sys.set_asyncgen_hook_firstiter", NULL) < 0) {
7100 : 0 : return -1;
7101 : : }
7102 : :
7103 : 10326 : Py_XINCREF(firstiter);
7104 [ + + + + ]: 10326 : Py_XSETREF(tstate->async_gen_firstiter, firstiter);
7105 : 10326 : return 0;
7106 : : }
7107 : :
7108 : : PyObject *
7109 : 5170 : _PyEval_GetAsyncGenFirstiter(void)
7110 : : {
7111 : 5170 : PyThreadState *tstate = _PyThreadState_GET();
7112 : 5170 : return tstate->async_gen_firstiter;
7113 : : }
7114 : :
7115 : : int
7116 : 10326 : _PyEval_SetAsyncGenFinalizer(PyObject *finalizer)
7117 : : {
7118 : 10326 : PyThreadState *tstate = _PyThreadState_GET();
7119 : :
7120 [ - + ]: 10326 : if (_PySys_Audit(tstate, "sys.set_asyncgen_hook_finalizer", NULL) < 0) {
7121 : 0 : return -1;
7122 : : }
7123 : :
7124 : 10326 : Py_XINCREF(finalizer);
7125 [ + + + + ]: 10326 : Py_XSETREF(tstate->async_gen_finalizer, finalizer);
7126 : 10326 : return 0;
7127 : : }
7128 : :
7129 : : PyObject *
7130 : 5170 : _PyEval_GetAsyncGenFinalizer(void)
7131 : : {
7132 : 5170 : PyThreadState *tstate = _PyThreadState_GET();
7133 : 5170 : return tstate->async_gen_finalizer;
7134 : : }
7135 : :
7136 : : _PyInterpreterFrame *
7137 : 3170 : _PyEval_GetFrame(void)
7138 : : {
7139 : 3170 : PyThreadState *tstate = _PyThreadState_GET();
7140 : 3170 : return tstate->cframe->current_frame;
7141 : : }
7142 : :
7143 : : PyFrameObject *
7144 : 0 : PyEval_GetFrame(void)
7145 : : {
7146 : 0 : PyThreadState *tstate = _PyThreadState_GET();
7147 [ # # ]: 0 : if (tstate->cframe->current_frame == NULL) {
7148 : 0 : return NULL;
7149 : : }
7150 : 0 : PyFrameObject *f = _PyFrame_GetFrameObject(tstate->cframe->current_frame);
7151 [ # # ]: 0 : if (f == NULL) {
7152 : 0 : PyErr_Clear();
7153 : : }
7154 : 0 : return f;
7155 : : }
7156 : :
7157 : : PyObject *
7158 : 249221 : _PyEval_GetBuiltins(PyThreadState *tstate)
7159 : : {
7160 : 249221 : _PyInterpreterFrame *frame = tstate->cframe->current_frame;
7161 [ + + ]: 249221 : if (frame != NULL) {
7162 : 242952 : return frame->f_builtins;
7163 : : }
7164 : 6269 : return tstate->interp->builtins;
7165 : : }
7166 : :
7167 : : PyObject *
7168 : 249150 : PyEval_GetBuiltins(void)
7169 : : {
7170 : 249150 : PyThreadState *tstate = _PyThreadState_GET();
7171 : 249150 : return _PyEval_GetBuiltins(tstate);
7172 : : }
7173 : :
7174 : : /* Convenience function to get a builtin from its name */
7175 : : PyObject *
7176 : 4289 : _PyEval_GetBuiltin(PyObject *name)
7177 : : {
7178 : 4289 : PyThreadState *tstate = _PyThreadState_GET();
7179 : 4289 : PyObject *attr = PyDict_GetItemWithError(PyEval_GetBuiltins(), name);
7180 [ + - ]: 4289 : if (attr) {
7181 : 4289 : Py_INCREF(attr);
7182 : : }
7183 [ # # ]: 0 : else if (!_PyErr_Occurred(tstate)) {
7184 : 0 : _PyErr_SetObject(tstate, PyExc_AttributeError, name);
7185 : : }
7186 : 4289 : return attr;
7187 : : }
7188 : :
7189 : : PyObject *
7190 : 0 : _PyEval_GetBuiltinId(_Py_Identifier *name)
7191 : : {
7192 : 0 : return _PyEval_GetBuiltin(_PyUnicode_FromId(name));
7193 : : }
7194 : :
7195 : : PyObject *
7196 : 20642 : PyEval_GetLocals(void)
7197 : : {
7198 : 20642 : PyThreadState *tstate = _PyThreadState_GET();
7199 : 20642 : _PyInterpreterFrame *current_frame = tstate->cframe->current_frame;
7200 [ - + ]: 20642 : if (current_frame == NULL) {
7201 : 0 : _PyErr_SetString(tstate, PyExc_SystemError, "frame does not exist");
7202 : 0 : return NULL;
7203 : : }
7204 : :
7205 [ - + ]: 20642 : if (_PyFrame_FastToLocalsWithError(current_frame) < 0) {
7206 : 0 : return NULL;
7207 : : }
7208 : :
7209 : 20642 : PyObject *locals = current_frame->f_locals;
7210 : : assert(locals != NULL);
7211 : 20642 : return locals;
7212 : : }
7213 : :
7214 : : PyObject *
7215 : 689541 : PyEval_GetGlobals(void)
7216 : : {
7217 : 689541 : PyThreadState *tstate = _PyThreadState_GET();
7218 : 689541 : _PyInterpreterFrame *current_frame = tstate->cframe->current_frame;
7219 [ + + ]: 689541 : if (current_frame == NULL) {
7220 : 28030 : return NULL;
7221 : : }
7222 : 661511 : return current_frame->f_globals;
7223 : : }
7224 : :
7225 : : int
7226 : 108510 : PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
7227 : : {
7228 : 108510 : PyThreadState *tstate = _PyThreadState_GET();
7229 : 108510 : _PyInterpreterFrame *current_frame = tstate->cframe->current_frame;
7230 : 108510 : int result = cf->cf_flags != 0;
7231 : :
7232 [ + - ]: 108510 : if (current_frame != NULL) {
7233 : 108510 : const int codeflags = current_frame->f_code->co_flags;
7234 : 108510 : const int compilerflags = codeflags & PyCF_MASK;
7235 [ - + ]: 108510 : if (compilerflags) {
7236 : 0 : result = 1;
7237 : 0 : cf->cf_flags |= compilerflags;
7238 : : }
7239 : : }
7240 : 108510 : return result;
7241 : : }
7242 : :
7243 : :
7244 : : const char *
7245 : 0 : PyEval_GetFuncName(PyObject *func)
7246 : : {
7247 [ # # ]: 0 : if (PyMethod_Check(func))
7248 : 0 : return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
7249 [ # # ]: 0 : else if (PyFunction_Check(func))
7250 : 0 : return PyUnicode_AsUTF8(((PyFunctionObject*)func)->func_name);
7251 [ # # ]: 0 : else if (PyCFunction_Check(func))
7252 : 0 : return ((PyCFunctionObject*)func)->m_ml->ml_name;
7253 : : else
7254 : 0 : return Py_TYPE(func)->tp_name;
7255 : : }
7256 : :
7257 : : const char *
7258 : 0 : PyEval_GetFuncDesc(PyObject *func)
7259 : : {
7260 [ # # ]: 0 : if (PyMethod_Check(func))
7261 : 0 : return "()";
7262 [ # # ]: 0 : else if (PyFunction_Check(func))
7263 : 0 : return "()";
7264 [ # # ]: 0 : else if (PyCFunction_Check(func))
7265 : 0 : return "()";
7266 : : else
7267 : 0 : return " object";
7268 : : }
7269 : :
7270 : : #define C_TRACE(x, call) \
7271 : : if (use_tracing && tstate->c_profilefunc) { \
7272 : : if (call_trace(tstate->c_profilefunc, tstate->c_profileobj, \
7273 : : tstate, tstate->cframe->current_frame, \
7274 : : PyTrace_C_CALL, func)) { \
7275 : : x = NULL; \
7276 : : } \
7277 : : else { \
7278 : : x = call; \
7279 : : if (tstate->c_profilefunc != NULL) { \
7280 : : if (x == NULL) { \
7281 : : call_trace_protected(tstate->c_profilefunc, \
7282 : : tstate->c_profileobj, \
7283 : : tstate, tstate->cframe->current_frame, \
7284 : : PyTrace_C_EXCEPTION, func); \
7285 : : /* XXX should pass (type, value, tb) */ \
7286 : : } else { \
7287 : : if (call_trace(tstate->c_profilefunc, \
7288 : : tstate->c_profileobj, \
7289 : : tstate, tstate->cframe->current_frame, \
7290 : : PyTrace_C_RETURN, func)) { \
7291 : : Py_DECREF(x); \
7292 : : x = NULL; \
7293 : : } \
7294 : : } \
7295 : : } \
7296 : : } \
7297 : : } else { \
7298 : : x = call; \
7299 : : }
7300 : :
7301 : :
7302 : : static PyObject *
7303 : 1992766 : trace_call_function(PyThreadState *tstate,
7304 : : PyObject *func,
7305 : : PyObject **args, Py_ssize_t nargs,
7306 : : PyObject *kwnames)
7307 : : {
7308 : 1992766 : int use_tracing = 1;
7309 : : PyObject *x;
7310 [ + + + + ]: 1992766 : if (PyCFunction_CheckExact(func) || PyCMethod_CheckExact(func)) {
7311 [ + - + + : 807021 : C_TRACE(x, PyObject_Vectorcall(func, args, nargs, kwnames));
- + + + +
+ - + -
- ]
7312 : 807021 : return x;
7313 : : }
7314 [ + + + + ]: 1185745 : else if (Py_IS_TYPE(func, &PyMethodDescr_Type) && nargs > 0) {
7315 : : /* We need to create a temporary bound method as argument
7316 : : for profiling.
7317 : :
7318 : : If nargs == 0, then this cannot work because we have no
7319 : : "self". In any case, the call itself would raise
7320 : : TypeError (foo needs an argument), so we just skip
7321 : : profiling. */
7322 : 1116743 : PyObject *self = args[0];
7323 : 1116743 : func = Py_TYPE(func)->tp_descr_get(func, self, (PyObject*)Py_TYPE(self));
7324 [ + + ]: 1116743 : if (func == NULL) {
7325 : 1 : return NULL;
7326 : : }
7327 [ + - + + : 1116742 : C_TRACE(x, PyObject_Vectorcall(func,
- + + + +
+ - + -
- ]
7328 : : args+1, nargs-1,
7329 : : kwnames));
7330 [ + - ]: 1116742 : Py_DECREF(func);
7331 : 1116742 : return x;
7332 : : }
7333 : 69002 : return PyObject_Vectorcall(func, args, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
7334 : : }
7335 : :
7336 : : static PyObject *
7337 : 9573973 : do_call_core(PyThreadState *tstate,
7338 : : PyObject *func,
7339 : : PyObject *callargs,
7340 : : PyObject *kwdict,
7341 : : int use_tracing
7342 : : )
7343 : : {
7344 : : PyObject *result;
7345 [ + + + + ]: 9573973 : if (PyCFunction_CheckExact(func) || PyCMethod_CheckExact(func)) {
7346 [ + + + + : 1625107 : C_TRACE(result, PyObject_Call(func, callargs, kwdict));
- + + + -
+ - + -
- ]
7347 : 1625107 : return result;
7348 : : }
7349 [ + + ]: 7948866 : else if (Py_IS_TYPE(func, &PyMethodDescr_Type)) {
7350 : 311 : Py_ssize_t nargs = PyTuple_GET_SIZE(callargs);
7351 [ + + + + ]: 311 : if (nargs > 0 && use_tracing) {
7352 : : /* We need to create a temporary bound method as argument
7353 : : for profiling.
7354 : :
7355 : : If nargs == 0, then this cannot work because we have no
7356 : : "self". In any case, the call itself would raise
7357 : : TypeError (foo needs an argument), so we just skip
7358 : : profiling. */
7359 : 2 : PyObject *self = PyTuple_GET_ITEM(callargs, 0);
7360 : 2 : func = Py_TYPE(func)->tp_descr_get(func, self, (PyObject*)Py_TYPE(self));
7361 [ + + ]: 2 : if (func == NULL) {
7362 : 1 : return NULL;
7363 : : }
7364 : :
7365 [ + - + - : 1 : C_TRACE(result, _PyObject_FastCallDictTstate(
- + + - -
+ - + -
- ]
7366 : : tstate, func,
7367 : : &_PyTuple_ITEMS(callargs)[1],
7368 : : nargs - 1,
7369 : : kwdict));
7370 [ + - ]: 1 : Py_DECREF(func);
7371 : 1 : return result;
7372 : : }
7373 : : }
7374 : : EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func);
7375 : 7948864 : return PyObject_Call(func, callargs, kwdict);
7376 : : }
7377 : :
7378 : : /* Extract a slice index from a PyLong or an object with the
7379 : : nb_index slot defined, and store in *pi.
7380 : : Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
7381 : : and silently boost values less than PY_SSIZE_T_MIN to PY_SSIZE_T_MIN.
7382 : : Return 0 on error, 1 on success.
7383 : : */
7384 : : int
7385 : 64232634 : _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
7386 : : {
7387 : 64232634 : PyThreadState *tstate = _PyThreadState_GET();
7388 [ + - ]: 64232634 : if (!Py_IsNone(v)) {
7389 : : Py_ssize_t x;
7390 [ + + ]: 64232634 : if (_PyIndex_Check(v)) {
7391 : 64232633 : x = PyNumber_AsSsize_t(v, NULL);
7392 [ + + + + ]: 64232633 : if (x == -1 && _PyErr_Occurred(tstate))
7393 : 12 : return 0;
7394 : : }
7395 : : else {
7396 : 1 : _PyErr_SetString(tstate, PyExc_TypeError,
7397 : : "slice indices must be integers or "
7398 : : "None or have an __index__ method");
7399 : 1 : return 0;
7400 : : }
7401 : 64232621 : *pi = x;
7402 : : }
7403 : 64232621 : return 1;
7404 : : }
7405 : :
7406 : : int
7407 : 272872 : _PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi)
7408 : : {
7409 : 272872 : PyThreadState *tstate = _PyThreadState_GET();
7410 : : Py_ssize_t x;
7411 [ + - ]: 272872 : if (_PyIndex_Check(v)) {
7412 : 272872 : x = PyNumber_AsSsize_t(v, NULL);
7413 [ + + - + ]: 272872 : if (x == -1 && _PyErr_Occurred(tstate))
7414 : 0 : return 0;
7415 : : }
7416 : : else {
7417 : 0 : _PyErr_SetString(tstate, PyExc_TypeError,
7418 : : "slice indices must be integers or "
7419 : : "have an __index__ method");
7420 : 0 : return 0;
7421 : : }
7422 : 272872 : *pi = x;
7423 : 272872 : return 1;
7424 : : }
7425 : :
7426 : : static PyObject *
7427 : 1443142 : import_name(PyThreadState *tstate, _PyInterpreterFrame *frame,
7428 : : PyObject *name, PyObject *fromlist, PyObject *level)
7429 : : {
7430 : : PyObject *import_func, *res;
7431 : : PyObject* stack[5];
7432 : :
7433 : 1443142 : import_func = _PyDict_GetItemWithError(frame->f_builtins, &_Py_ID(__import__));
7434 [ + + ]: 1443142 : if (import_func == NULL) {
7435 [ + - ]: 1 : if (!_PyErr_Occurred(tstate)) {
7436 : 1 : _PyErr_SetString(tstate, PyExc_ImportError, "__import__ not found");
7437 : : }
7438 : 1 : return NULL;
7439 : : }
7440 : 1443141 : PyObject *locals = frame->f_locals;
7441 : : /* Fast path for not overloaded __import__. */
7442 [ + + ]: 1443141 : if (import_func == tstate->interp->import_func) {
7443 : 1443139 : int ilevel = _PyLong_AsInt(level);
7444 [ - + - - ]: 1443139 : if (ilevel == -1 && _PyErr_Occurred(tstate)) {
7445 : 0 : return NULL;
7446 : : }
7447 [ + + ]: 1443139 : res = PyImport_ImportModuleLevelObject(
7448 : : name,
7449 : : frame->f_globals,
7450 : : locals == NULL ? Py_None :locals,
7451 : : fromlist,
7452 : : ilevel);
7453 : 1443139 : return res;
7454 : : }
7455 : :
7456 : 2 : Py_INCREF(import_func);
7457 : :
7458 : 2 : stack[0] = name;
7459 : 2 : stack[1] = frame->f_globals;
7460 [ - + ]: 2 : stack[2] = locals == NULL ? Py_None : locals;
7461 : 2 : stack[3] = fromlist;
7462 : 2 : stack[4] = level;
7463 : 2 : res = _PyObject_FastCall(import_func, stack, 5);
7464 [ - + ]: 2 : Py_DECREF(import_func);
7465 : 2 : return res;
7466 : : }
7467 : :
7468 : : static PyObject *
7469 : 807403 : import_from(PyThreadState *tstate, PyObject *v, PyObject *name)
7470 : : {
7471 : : PyObject *x;
7472 : : PyObject *fullmodname, *pkgname, *pkgpath, *pkgname_or_unknown, *errmsg;
7473 : :
7474 [ + + ]: 807403 : if (_PyObject_LookupAttr(v, name, &x) != 0) {
7475 : 801964 : return x;
7476 : : }
7477 : : /* Issue #17636: in case this failed because of a circular relative
7478 : : import, try to fallback on reading the module directly from
7479 : : sys.modules. */
7480 : 5439 : pkgname = PyObject_GetAttr(v, &_Py_ID(__name__));
7481 [ + + ]: 5439 : if (pkgname == NULL) {
7482 : 1 : goto error;
7483 : : }
7484 [ + + ]: 5438 : if (!PyUnicode_Check(pkgname)) {
7485 [ + - - + ]: 1 : Py_CLEAR(pkgname);
7486 : 1 : goto error;
7487 : : }
7488 : 5437 : fullmodname = PyUnicode_FromFormat("%U.%U", pkgname, name);
7489 [ - + ]: 5437 : if (fullmodname == NULL) {
7490 [ # # ]: 0 : Py_DECREF(pkgname);
7491 : 0 : return NULL;
7492 : : }
7493 : 5437 : x = PyImport_GetModule(fullmodname);
7494 [ + - ]: 5437 : Py_DECREF(fullmodname);
7495 [ + + + - ]: 5437 : if (x == NULL && !_PyErr_Occurred(tstate)) {
7496 : 4761 : goto error;
7497 : : }
7498 [ - + ]: 676 : Py_DECREF(pkgname);
7499 : 676 : return x;
7500 : 4763 : error:
7501 : 4763 : pkgpath = PyModule_GetFilenameObject(v);
7502 [ + + ]: 4763 : if (pkgname == NULL) {
7503 : 2 : pkgname_or_unknown = PyUnicode_FromString("<unknown module name>");
7504 [ - + ]: 2 : if (pkgname_or_unknown == NULL) {
7505 [ # # # # ]: 0 : Py_XDECREF(pkgpath);
7506 : 0 : return NULL;
7507 : : }
7508 : : } else {
7509 : 4761 : pkgname_or_unknown = pkgname;
7510 : : }
7511 : :
7512 [ + + - + ]: 4763 : if (pkgpath == NULL || !PyUnicode_Check(pkgpath)) {
7513 : 3134 : _PyErr_Clear(tstate);
7514 : 3134 : errmsg = PyUnicode_FromFormat(
7515 : : "cannot import name %R from %R (unknown location)",
7516 : : name, pkgname_or_unknown
7517 : : );
7518 : : /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */
7519 : 3134 : PyErr_SetImportError(errmsg, pkgname, NULL);
7520 : : }
7521 : : else {
7522 : 1629 : PyObject *spec = PyObject_GetAttr(v, &_Py_ID(__spec__));
7523 : 1629 : const char *fmt =
7524 : 1629 : _PyModuleSpec_IsInitializing(spec) ?
7525 : : "cannot import name %R from partially initialized module %R "
7526 [ + + ]: 1629 : "(most likely due to a circular import) (%S)" :
7527 : : "cannot import name %R from %R (%S)";
7528 [ + - - + ]: 1629 : Py_XDECREF(spec);
7529 : :
7530 : 1629 : errmsg = PyUnicode_FromFormat(fmt, name, pkgname_or_unknown, pkgpath);
7531 : : /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */
7532 : 1629 : PyErr_SetImportError(errmsg, pkgname, pkgpath);
7533 : : }
7534 : :
7535 [ + - - + ]: 4763 : Py_XDECREF(errmsg);
7536 [ + - + + ]: 4763 : Py_XDECREF(pkgname_or_unknown);
7537 [ + + - + ]: 4763 : Py_XDECREF(pkgpath);
7538 : 4763 : return NULL;
7539 : : }
7540 : :
7541 : : static int
7542 : 40974 : import_all_from(PyThreadState *tstate, PyObject *locals, PyObject *v)
7543 : : {
7544 : : PyObject *all, *dict, *name, *value;
7545 : 40974 : int skip_leading_underscores = 0;
7546 : : int pos, err;
7547 : :
7548 [ - + ]: 40974 : if (_PyObject_LookupAttr(v, &_Py_ID(__all__), &all) < 0) {
7549 : 0 : return -1; /* Unexpected error */
7550 : : }
7551 [ + + ]: 40974 : if (all == NULL) {
7552 [ - + ]: 25910 : if (_PyObject_LookupAttr(v, &_Py_ID(__dict__), &dict) < 0) {
7553 : 0 : return -1;
7554 : : }
7555 [ - + ]: 25910 : if (dict == NULL) {
7556 : 0 : _PyErr_SetString(tstate, PyExc_ImportError,
7557 : : "from-import-* object has no __dict__ and no __all__");
7558 : 0 : return -1;
7559 : : }
7560 : 25910 : all = PyMapping_Keys(dict);
7561 [ - + ]: 25910 : Py_DECREF(dict);
7562 [ - + ]: 25910 : if (all == NULL)
7563 : 0 : return -1;
7564 : 25910 : skip_leading_underscores = 1;
7565 : : }
7566 : :
7567 : 40974 : for (pos = 0, err = 0; ; pos++) {
7568 : 3038657 : name = PySequence_GetItem(all, pos);
7569 [ + + ]: 3038657 : if (name == NULL) {
7570 [ - + ]: 40972 : if (!_PyErr_ExceptionMatches(tstate, PyExc_IndexError)) {
7571 : 0 : err = -1;
7572 : : }
7573 : : else {
7574 : 40972 : _PyErr_Clear(tstate);
7575 : : }
7576 : 40972 : break;
7577 : : }
7578 [ + + ]: 2997685 : if (!PyUnicode_Check(name)) {
7579 : 2 : PyObject *modname = PyObject_GetAttr(v, &_Py_ID(__name__));
7580 [ - + ]: 2 : if (modname == NULL) {
7581 [ # # ]: 0 : Py_DECREF(name);
7582 : 0 : err = -1;
7583 : 0 : break;
7584 : : }
7585 [ - + ]: 2 : if (!PyUnicode_Check(modname)) {
7586 : 0 : _PyErr_Format(tstate, PyExc_TypeError,
7587 : : "module __name__ must be a string, not %.100s",
7588 : 0 : Py_TYPE(modname)->tp_name);
7589 : : }
7590 : : else {
7591 [ + + + + ]: 2 : _PyErr_Format(tstate, PyExc_TypeError,
7592 : : "%s in %U.%s must be str, not %.100s",
7593 : : skip_leading_underscores ? "Key" : "Item",
7594 : : modname,
7595 : : skip_leading_underscores ? "__dict__" : "__all__",
7596 : 2 : Py_TYPE(name)->tp_name);
7597 : : }
7598 [ - + ]: 2 : Py_DECREF(modname);
7599 [ - + ]: 2 : Py_DECREF(name);
7600 : 2 : err = -1;
7601 : 2 : break;
7602 : : }
7603 [ + + ]: 2997683 : if (skip_leading_underscores) {
7604 [ - + ]: 2750702 : if (PyUnicode_READY(name) == -1) {
7605 [ # # ]: 0 : Py_DECREF(name);
7606 : 0 : err = -1;
7607 : 0 : break;
7608 : : }
7609 [ + + ]: 2750702 : if (PyUnicode_READ_CHAR(name, 0) == '_') {
7610 [ - + ]: 188995 : Py_DECREF(name);
7611 : 188995 : continue;
7612 : : }
7613 : : }
7614 : 2808688 : value = PyObject_GetAttr(v, name);
7615 [ - + ]: 2808688 : if (value == NULL)
7616 : 0 : err = -1;
7617 [ + - ]: 2808688 : else if (PyDict_CheckExact(locals))
7618 : 2808688 : err = PyDict_SetItem(locals, name, value);
7619 : : else
7620 : 0 : err = PyObject_SetItem(locals, name, value);
7621 [ - + ]: 2808688 : Py_DECREF(name);
7622 [ + - - + ]: 2808688 : Py_XDECREF(value);
7623 [ - + ]: 2808688 : if (err != 0)
7624 : 0 : break;
7625 : : }
7626 [ + + ]: 40974 : Py_DECREF(all);
7627 : 40974 : return err;
7628 : : }
7629 : :
7630 : : #define CANNOT_CATCH_MSG "catching classes that do not inherit from "\
7631 : : "BaseException is not allowed"
7632 : :
7633 : : #define CANNOT_EXCEPT_STAR_EG "catching ExceptionGroup with except* "\
7634 : : "is not allowed. Use except instead."
7635 : :
7636 : : static int
7637 : 3558790 : check_except_type_valid(PyThreadState *tstate, PyObject* right)
7638 : : {
7639 [ + + ]: 3558790 : if (PyTuple_Check(right)) {
7640 : : Py_ssize_t i, length;
7641 : 209420 : length = PyTuple_GET_SIZE(right);
7642 [ + + ]: 646777 : for (i = 0; i < length; i++) {
7643 : 437363 : PyObject *exc = PyTuple_GET_ITEM(right, i);
7644 [ + + + + ]: 437363 : if (!PyExceptionClass_Check(exc)) {
7645 : 6 : _PyErr_SetString(tstate, PyExc_TypeError,
7646 : : CANNOT_CATCH_MSG);
7647 : 6 : return -1;
7648 : : }
7649 : : }
7650 : : }
7651 : : else {
7652 [ + + + + ]: 3349370 : if (!PyExceptionClass_Check(right)) {
7653 : 6 : _PyErr_SetString(tstate, PyExc_TypeError,
7654 : : CANNOT_CATCH_MSG);
7655 : 6 : return -1;
7656 : : }
7657 : : }
7658 : 3558778 : return 0;
7659 : : }
7660 : :
7661 : : static int
7662 : 179 : check_except_star_type_valid(PyThreadState *tstate, PyObject* right)
7663 : : {
7664 [ + + ]: 179 : if (check_except_type_valid(tstate, right) < 0) {
7665 : 2 : return -1;
7666 : : }
7667 : :
7668 : : /* reject except *ExceptionGroup */
7669 : :
7670 : 177 : int is_subclass = 0;
7671 [ + + ]: 177 : if (PyTuple_Check(right)) {
7672 : 13 : Py_ssize_t length = PyTuple_GET_SIZE(right);
7673 [ + + ]: 40 : for (Py_ssize_t i = 0; i < length; i++) {
7674 : 28 : PyObject *exc = PyTuple_GET_ITEM(right, i);
7675 : 28 : is_subclass = PyObject_IsSubclass(exc, PyExc_BaseExceptionGroup);
7676 [ - + ]: 28 : if (is_subclass < 0) {
7677 : 0 : return -1;
7678 : : }
7679 [ + + ]: 28 : if (is_subclass) {
7680 : 1 : break;
7681 : : }
7682 : : }
7683 : : }
7684 : : else {
7685 : 164 : is_subclass = PyObject_IsSubclass(right, PyExc_BaseExceptionGroup);
7686 [ - + ]: 164 : if (is_subclass < 0) {
7687 : 0 : return -1;
7688 : : }
7689 : : }
7690 [ + + ]: 177 : if (is_subclass) {
7691 : 2 : _PyErr_SetString(tstate, PyExc_TypeError,
7692 : : CANNOT_EXCEPT_STAR_EG);
7693 : 2 : return -1;
7694 : : }
7695 : 175 : return 0;
7696 : : }
7697 : :
7698 : : static int
7699 : 344035 : check_args_iterable(PyThreadState *tstate, PyObject *func, PyObject *args)
7700 : : {
7701 [ + + + + ]: 344035 : if (Py_TYPE(args)->tp_iter == NULL && !PySequence_Check(args)) {
7702 : : /* check_args_iterable() may be called with a live exception:
7703 : : * clear it to prevent calling _PyObject_FunctionStr() with an
7704 : : * exception set. */
7705 : 6 : _PyErr_Clear(tstate);
7706 : 6 : PyObject *funcstr = _PyObject_FunctionStr(func);
7707 [ + - ]: 6 : if (funcstr != NULL) {
7708 : 6 : _PyErr_Format(tstate, PyExc_TypeError,
7709 : : "%U argument after * must be an iterable, not %.200s",
7710 : 6 : funcstr, Py_TYPE(args)->tp_name);
7711 [ + - ]: 6 : Py_DECREF(funcstr);
7712 : : }
7713 : 6 : return -1;
7714 : : }
7715 : 344029 : return 0;
7716 : : }
7717 : :
7718 : : static void
7719 : 23 : format_kwargs_error(PyThreadState *tstate, PyObject *func, PyObject *kwargs)
7720 : : {
7721 : : /* _PyDict_MergeEx raises attribute
7722 : : * error (percolated from an attempt
7723 : : * to get 'keys' attribute) instead of
7724 : : * a type error if its second argument
7725 : : * is not a mapping.
7726 : : */
7727 [ + + ]: 23 : if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
7728 : 9 : _PyErr_Clear(tstate);
7729 : 9 : PyObject *funcstr = _PyObject_FunctionStr(func);
7730 [ + - ]: 9 : if (funcstr != NULL) {
7731 : 9 : _PyErr_Format(
7732 : : tstate, PyExc_TypeError,
7733 : : "%U argument after ** must be a mapping, not %.200s",
7734 : 9 : funcstr, Py_TYPE(kwargs)->tp_name);
7735 [ + - ]: 9 : Py_DECREF(funcstr);
7736 : : }
7737 : : }
7738 [ + + ]: 14 : else if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
7739 : : PyObject *exc, *val, *tb;
7740 : 13 : _PyErr_Fetch(tstate, &exc, &val, &tb);
7741 [ + - + - : 26 : if (val && PyTuple_Check(val) && PyTuple_GET_SIZE(val) == 1) {
+ - ]
7742 : 13 : _PyErr_Clear(tstate);
7743 : 13 : PyObject *funcstr = _PyObject_FunctionStr(func);
7744 [ + - ]: 13 : if (funcstr != NULL) {
7745 : 13 : PyObject *key = PyTuple_GET_ITEM(val, 0);
7746 : 13 : _PyErr_Format(
7747 : : tstate, PyExc_TypeError,
7748 : : "%U got multiple values for keyword argument '%S'",
7749 : : funcstr, key);
7750 [ + - ]: 13 : Py_DECREF(funcstr);
7751 : : }
7752 [ + - - + ]: 13 : Py_XDECREF(exc);
7753 [ + - + - ]: 13 : Py_XDECREF(val);
7754 [ - + - - ]: 13 : Py_XDECREF(tb);
7755 : : }
7756 : : else {
7757 : 0 : _PyErr_Restore(tstate, exc, val, tb);
7758 : : }
7759 : : }
7760 : 23 : }
7761 : :
7762 : : static void
7763 : 967 : format_exc_check_arg(PyThreadState *tstate, PyObject *exc,
7764 : : const char *format_str, PyObject *obj)
7765 : : {
7766 : : const char *obj_str;
7767 : :
7768 [ - + ]: 967 : if (!obj)
7769 : 0 : return;
7770 : :
7771 : 967 : obj_str = PyUnicode_AsUTF8(obj);
7772 [ - + ]: 967 : if (!obj_str)
7773 : 0 : return;
7774 : :
7775 : 967 : _PyErr_Format(tstate, exc, format_str, obj_str);
7776 : :
7777 [ + + ]: 967 : if (exc == PyExc_NameError) {
7778 : : // Include the name in the NameError exceptions to offer suggestions later.
7779 : : PyObject *type, *value, *traceback;
7780 : 958 : PyErr_Fetch(&type, &value, &traceback);
7781 : 958 : PyErr_NormalizeException(&type, &value, &traceback);
7782 [ + - ]: 958 : if (PyErr_GivenExceptionMatches(value, PyExc_NameError)) {
7783 : 958 : PyNameErrorObject* exc = (PyNameErrorObject*) value;
7784 [ + - ]: 958 : if (exc->name == NULL) {
7785 : : // We do not care if this fails because we are going to restore the
7786 : : // NameError anyway.
7787 : 958 : (void)PyObject_SetAttr(value, &_Py_ID(name), obj);
7788 : : }
7789 : : }
7790 : 958 : PyErr_Restore(type, value, traceback);
7791 : : }
7792 : : }
7793 : :
7794 : : static void
7795 : 8 : format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg)
7796 : : {
7797 : : PyObject *name;
7798 : : /* Don't stomp existing exception */
7799 [ - + ]: 8 : if (_PyErr_Occurred(tstate))
7800 : 0 : return;
7801 : 8 : name = PyTuple_GET_ITEM(co->co_localsplusnames, oparg);
7802 [ + + ]: 8 : if (oparg < co->co_nplaincellvars + co->co_nlocals) {
7803 : 3 : format_exc_check_arg(tstate, PyExc_UnboundLocalError,
7804 : : UNBOUNDLOCAL_ERROR_MSG, name);
7805 : : } else {
7806 : 5 : format_exc_check_arg(tstate, PyExc_NameError,
7807 : : UNBOUNDFREE_ERROR_MSG, name);
7808 : : }
7809 : : }
7810 : :
7811 : : static void
7812 : 28 : format_awaitable_error(PyThreadState *tstate, PyTypeObject *type, int oparg)
7813 : : {
7814 [ + + + + ]: 28 : if (type->tp_as_async == NULL || type->tp_as_async->am_await == NULL) {
7815 [ + + ]: 23 : if (oparg == 1) {
7816 : 1 : _PyErr_Format(tstate, PyExc_TypeError,
7817 : : "'async with' received an object from __aenter__ "
7818 : : "that does not implement __await__: %.100s",
7819 : : type->tp_name);
7820 : : }
7821 [ + + ]: 22 : else if (oparg == 2) {
7822 : 5 : _PyErr_Format(tstate, PyExc_TypeError,
7823 : : "'async with' received an object from __aexit__ "
7824 : : "that does not implement __await__: %.100s",
7825 : : type->tp_name);
7826 : : }
7827 : : }
7828 : 28 : }
7829 : :
7830 : : #ifdef Py_STATS
7831 : :
7832 : : static PyObject *
7833 : : getarray(uint64_t a[256])
7834 : : {
7835 : : int i;
7836 : : PyObject *l = PyList_New(256);
7837 : : if (l == NULL) return NULL;
7838 : : for (i = 0; i < 256; i++) {
7839 : : PyObject *x = PyLong_FromUnsignedLongLong(a[i]);
7840 : : if (x == NULL) {
7841 : : Py_DECREF(l);
7842 : : return NULL;
7843 : : }
7844 : : PyList_SET_ITEM(l, i, x);
7845 : : }
7846 : : for (i = 0; i < 256; i++)
7847 : : a[i] = 0;
7848 : : return l;
7849 : : }
7850 : :
7851 : : PyObject *
7852 : : _Py_GetDXProfile(PyObject *self, PyObject *args)
7853 : : {
7854 : : int i;
7855 : : PyObject *l = PyList_New(257);
7856 : : if (l == NULL) return NULL;
7857 : : for (i = 0; i < 256; i++) {
7858 : : PyObject *x = getarray(_py_stats_struct.opcode_stats[i].pair_count);
7859 : : if (x == NULL) {
7860 : : Py_DECREF(l);
7861 : : return NULL;
7862 : : }
7863 : : PyList_SET_ITEM(l, i, x);
7864 : : }
7865 : : PyObject *counts = PyList_New(256);
7866 : : if (counts == NULL) {
7867 : : Py_DECREF(l);
7868 : : return NULL;
7869 : : }
7870 : : for (i = 0; i < 256; i++) {
7871 : : PyObject *x = PyLong_FromUnsignedLongLong(
7872 : : _py_stats_struct.opcode_stats[i].execution_count);
7873 : : if (x == NULL) {
7874 : : Py_DECREF(counts);
7875 : : Py_DECREF(l);
7876 : : return NULL;
7877 : : }
7878 : : PyList_SET_ITEM(counts, i, x);
7879 : : }
7880 : : PyList_SET_ITEM(l, 256, counts);
7881 : : return l;
7882 : : }
7883 : :
7884 : : #endif
7885 : :
7886 : : Py_ssize_t
7887 : 1 : _PyEval_RequestCodeExtraIndex(freefunc free)
7888 : : {
7889 : 1 : PyInterpreterState *interp = _PyInterpreterState_GET();
7890 : : Py_ssize_t new_index;
7891 : :
7892 [ - + ]: 1 : if (interp->co_extra_user_count == MAX_CO_EXTRA_USERS - 1) {
7893 : 0 : return -1;
7894 : : }
7895 : 1 : new_index = interp->co_extra_user_count++;
7896 : 1 : interp->co_extra_freefuncs[new_index] = free;
7897 : 1 : return new_index;
7898 : : }
7899 : :
7900 : : static void
7901 : 0 : dtrace_function_entry(_PyInterpreterFrame *frame)
7902 : : {
7903 : : const char *filename;
7904 : : const char *funcname;
7905 : : int lineno;
7906 : :
7907 : 0 : PyCodeObject *code = frame->f_code;
7908 : 0 : filename = PyUnicode_AsUTF8(code->co_filename);
7909 : 0 : funcname = PyUnicode_AsUTF8(code->co_name);
7910 : 0 : lineno = _PyInterpreterFrame_GetLine(frame);
7911 : :
7912 : 0 : PyDTrace_FUNCTION_ENTRY(filename, funcname, lineno);
7913 : 0 : }
7914 : :
7915 : : static void
7916 : 0 : dtrace_function_return(_PyInterpreterFrame *frame)
7917 : : {
7918 : : const char *filename;
7919 : : const char *funcname;
7920 : : int lineno;
7921 : :
7922 : 0 : PyCodeObject *code = frame->f_code;
7923 : 0 : filename = PyUnicode_AsUTF8(code->co_filename);
7924 : 0 : funcname = PyUnicode_AsUTF8(code->co_name);
7925 : 0 : lineno = _PyInterpreterFrame_GetLine(frame);
7926 : :
7927 : 0 : PyDTrace_FUNCTION_RETURN(filename, funcname, lineno);
7928 : 0 : }
7929 : :
7930 : : /* DTrace equivalent of maybe_call_line_trace. */
7931 : : static void
7932 : 0 : maybe_dtrace_line(_PyInterpreterFrame *frame,
7933 : : PyTraceInfo *trace_info,
7934 : : int instr_prev)
7935 : : {
7936 : : const char *co_filename, *co_name;
7937 : :
7938 : : /* If the last instruction executed isn't in the current
7939 : : instruction window, reset the window.
7940 : : */
7941 : 0 : initialize_trace_info(trace_info, frame);
7942 : 0 : int lastline = _PyCode_CheckLineNumber(instr_prev*sizeof(_Py_CODEUNIT), &trace_info->bounds);
7943 : 0 : int addr = _PyInterpreterFrame_LASTI(frame) * sizeof(_Py_CODEUNIT);
7944 : 0 : int line = _PyCode_CheckLineNumber(addr, &trace_info->bounds);
7945 [ # # ]: 0 : if (line != -1) {
7946 : : /* Trace backward edges or first instruction of a new line */
7947 [ # # # # ]: 0 : if (_PyInterpreterFrame_LASTI(frame) < instr_prev ||
7948 [ # # ]: 0 : (line != lastline && addr == trace_info->bounds.ar_start))
7949 : : {
7950 : 0 : co_filename = PyUnicode_AsUTF8(frame->f_code->co_filename);
7951 [ # # ]: 0 : if (!co_filename) {
7952 : 0 : co_filename = "?";
7953 : : }
7954 : 0 : co_name = PyUnicode_AsUTF8(frame->f_code->co_name);
7955 [ # # ]: 0 : if (!co_name) {
7956 : 0 : co_name = "?";
7957 : : }
7958 : 0 : PyDTrace_LINE(co_filename, co_name, line);
7959 : : }
7960 : : }
7961 : 0 : }
7962 : :
7963 : : /* Implement Py_EnterRecursiveCall() and Py_LeaveRecursiveCall() as functions
7964 : : for the limited API. */
7965 : :
7966 : : #undef Py_EnterRecursiveCall
7967 : :
7968 : 0 : int Py_EnterRecursiveCall(const char *where)
7969 : : {
7970 : 0 : return _Py_EnterRecursiveCall(where);
7971 : : }
7972 : :
7973 : : #undef Py_LeaveRecursiveCall
7974 : :
7975 : 0 : void Py_LeaveRecursiveCall(void)
7976 : : {
7977 : 0 : _Py_LeaveRecursiveCall();
7978 : 0 : }
|
