LCOV - code coverage report
Current view: top level - Python - ceval.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 472 1322 35.7 %
Date: 2023-03-20 08:15:36 Functions: 33 82 40.2 %
Branches: 251 1009 24.9 %

           Branch data     Line data    Source code
       1                 :            : /* Execute compiled code */
       2                 :            : 
       3                 :            : #define _PY_INTERPRETER
       4                 :            : 
       5                 :            : #include "Python.h"
       6                 :            : #include "pycore_abstract.h"      // _PyIndex_Check()
       7                 :            : #include "pycore_call.h"          // _PyObject_FastCallDictTstate()
       8                 :            : #include "pycore_ceval.h"         // _PyEval_SignalAsyncExc()
       9                 :            : #include "pycore_code.h"
      10                 :            : #include "pycore_function.h"
      11                 :            : #include "pycore_intrinsics.h"
      12                 :            : #include "pycore_long.h"          // _PyLong_GetZero()
      13                 :            : #include "pycore_object.h"        // _PyObject_GC_TRACK()
      14                 :            : #include "pycore_moduleobject.h"  // PyModuleObject
      15                 :            : #include "pycore_opcode.h"        // EXTRA_CASES
      16                 :            : #include "pycore_pyerrors.h"      // _PyErr_GetRaisedException()
      17                 :            : #include "pycore_pymem.h"         // _PyMem_IsPtrFreed()
      18                 :            : #include "pycore_pystate.h"       // _PyInterpreterState_GET()
      19                 :            : #include "pycore_range.h"         // _PyRangeIterObject
      20                 :            : #include "pycore_sliceobject.h"   // _PyBuildSlice_ConsumeRefs
      21                 :            : #include "pycore_sysmodule.h"     // _PySys_Audit()
      22                 :            : #include "pycore_tuple.h"         // _PyTuple_ITEMS()
      23                 :            : #include "pycore_emscripten_signal.h"  // _Py_CHECK_EMSCRIPTEN_SIGNALS
      24                 :            : 
      25                 :            : #include "pycore_dict.h"
      26                 :            : #include "dictobject.h"
      27                 :            : #include "pycore_frame.h"
      28                 :            : #include "opcode.h"
      29                 :            : #include "pydtrace.h"
      30                 :            : #include "setobject.h"
      31                 :            : #include "structmember.h"         // struct PyMemberDef, T_OFFSET_EX
      32                 :            : 
      33                 :            : #include <ctype.h>
      34                 :            : #include <stdbool.h>
      35                 :            : 
      36                 :            : #ifdef Py_DEBUG
      37                 :            :    /* For debugging the interpreter: */
      38                 :            : #  define LLTRACE  1      /* Low-level trace feature */
      39                 :            : #endif
      40                 :            : 
      41                 :            : #if !defined(Py_BUILD_CORE)
      42                 :            : #  error "ceval.c must be build with Py_BUILD_CORE define for best performance"
      43                 :            : #endif
      44                 :            : 
      45                 :            : #if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS)
      46                 :            : // GH-89279: The MSVC compiler does not inline these static inline functions
      47                 :            : // in PGO build in _PyEval_EvalFrameDefault(), because this function is over
      48                 :            : // the limit of PGO, and that limit cannot be configured.
      49                 :            : // Define them as macros to make sure that they are always inlined by the
      50                 :            : // preprocessor.
      51                 :            : 
      52                 :            : #undef Py_DECREF
      53                 :            : #define Py_DECREF(arg) \
      54                 :            :     do { \
      55                 :            :         _Py_DECREF_STAT_INC(); \
      56                 :            :         PyObject *op = _PyObject_CAST(arg); \
      57                 :            :         if (--op->ob_refcnt == 0) { \
      58                 :            :             destructor dealloc = Py_TYPE(op)->tp_dealloc; \
      59                 :            :             (*dealloc)(op); \
      60                 :            :         } \
      61                 :            :     } while (0)
      62                 :            : 
      63                 :            : #undef Py_XDECREF
      64                 :            : #define Py_XDECREF(arg) \
      65                 :            :     do { \
      66                 :            :         PyObject *xop = _PyObject_CAST(arg); \
      67                 :            :         if (xop != NULL) { \
      68                 :            :             Py_DECREF(xop); \
      69                 :            :         } \
      70                 :            :     } while (0)
      71                 :            : 
      72                 :            : #undef Py_IS_TYPE
      73                 :            : #define Py_IS_TYPE(ob, type) \
      74                 :            :     (_PyObject_CAST(ob)->ob_type == (type))
      75                 :            : 
      76                 :            : #undef _Py_DECREF_SPECIALIZED
      77                 :            : #define _Py_DECREF_SPECIALIZED(arg, dealloc) \
      78                 :            :     do { \
      79                 :            :         _Py_DECREF_STAT_INC(); \
      80                 :            :         PyObject *op = _PyObject_CAST(arg); \
      81                 :            :         if (--op->ob_refcnt == 0) { \
      82                 :            :             destructor d = (destructor)(dealloc); \
      83                 :            :             d(op); \
      84                 :            :         } \
      85                 :            :     } while (0)
      86                 :            : #endif
      87                 :            : 
      88                 :            : // GH-89279: Similar to above, force inlining by using a macro.
      89                 :            : #if defined(_MSC_VER) && SIZEOF_INT == 4
      90                 :            : #define _Py_atomic_load_relaxed_int32(ATOMIC_VAL) (assert(sizeof((ATOMIC_VAL)->_value) == 4), *((volatile int*)&((ATOMIC_VAL)->_value)))
      91                 :            : #else
      92                 :            : #define _Py_atomic_load_relaxed_int32(ATOMIC_VAL) _Py_atomic_load_relaxed(ATOMIC_VAL)
      93                 :            : #endif
      94                 :            : 
      95                 :            : /* Forward declarations */
      96                 :            : static PyObject *trace_call_function(
      97                 :            :     PyThreadState *tstate, PyObject *callable, PyObject **stack,
      98                 :            :     Py_ssize_t oparg, PyObject *kwnames);
      99                 :            : static PyObject * do_call_core(
     100                 :            :     PyThreadState *tstate, PyObject *func,
     101                 :            :     PyObject *callargs, PyObject *kwdict, int use_tracing);
     102                 :            : 
     103                 :            : #ifdef LLTRACE
     104                 :            : static void
     105                 :            : dump_stack(_PyInterpreterFrame *frame, PyObject **stack_pointer)
     106                 :            : {
     107                 :            :     PyObject **stack_base = _PyFrame_Stackbase(frame);
     108                 :            :     PyObject *exc = PyErr_GetRaisedException();
     109                 :            :     printf("    stack=[");
     110                 :            :     for (PyObject **ptr = stack_base; ptr < stack_pointer; ptr++) {
     111                 :            :         if (ptr != stack_base) {
     112                 :            :             printf(", ");
     113                 :            :         }
     114                 :            :         if (PyObject_Print(*ptr, stdout, 0) != 0) {
     115                 :            :             PyErr_Clear();
     116                 :            :             printf("<%s object at %p>",
     117                 :            :                    Py_TYPE(*ptr)->tp_name, (void *)(*ptr));
     118                 :            :         }
     119                 :            :     }
     120                 :            :     printf("]\n");
     121                 :            :     fflush(stdout);
     122                 :            :     PyErr_SetRaisedException(exc);
     123                 :            : }
     124                 :            : 
     125                 :            : static void
     126                 :            : lltrace_instruction(_PyInterpreterFrame *frame,
     127                 :            :                     PyObject **stack_pointer,
     128                 :            :                     _Py_CODEUNIT *next_instr)
     129                 :            : {
     130                 :            :     /* This dump_stack() operation is risky, since the repr() of some
     131                 :            :        objects enters the interpreter recursively. It is also slow.
     132                 :            :        So you might want to comment it out. */
     133                 :            :     dump_stack(frame, stack_pointer);
     134                 :            :     int oparg = next_instr->op.arg;
     135                 :            :     int opcode = next_instr->op.code;
     136                 :            :     const char *opname = _PyOpcode_OpName[opcode];
     137                 :            :     assert(opname != NULL);
     138                 :            :     int offset = (int)(next_instr - _PyCode_CODE(frame->f_code));
     139                 :            :     if (HAS_ARG((int)_PyOpcode_Deopt[opcode])) {
     140                 :            :         printf("%d: %s %d\n", offset * 2, opname, oparg);
     141                 :            :     }
     142                 :            :     else {
     143                 :            :         printf("%d: %s\n", offset * 2, opname);
     144                 :            :     }
     145                 :            :     fflush(stdout);
     146                 :            : }
     147                 :            : static void
     148                 :            : lltrace_resume_frame(_PyInterpreterFrame *frame)
     149                 :            : {
     150                 :            :     PyObject *fobj = frame->f_funcobj;
     151                 :            :     if (frame->owner == FRAME_OWNED_BY_CSTACK ||
     152                 :            :         fobj == NULL ||
     153                 :            :         !PyFunction_Check(fobj)
     154                 :            :     ) {
     155                 :            :         printf("\nResuming frame.\n");
     156                 :            :         return;
     157                 :            :     }
     158                 :            :     PyFunctionObject *f = (PyFunctionObject *)fobj;
     159                 :            :     PyObject *exc = PyErr_GetRaisedException();
     160                 :            :     PyObject *name = f->func_qualname;
     161                 :            :     if (name == NULL) {
     162                 :            :         name = f->func_name;
     163                 :            :     }
     164                 :            :     printf("\nResuming frame");
     165                 :            :     if (name) {
     166                 :            :         printf(" for ");
     167                 :            :         if (PyObject_Print(name, stdout, 0) < 0) {
     168                 :            :             PyErr_Clear();
     169                 :            :         }
     170                 :            :     }
     171                 :            :     if (f->func_module) {
     172                 :            :         printf(" in module ");
     173                 :            :         if (PyObject_Print(f->func_module, stdout, 0) < 0) {
     174                 :            :             PyErr_Clear();
     175                 :            :         }
     176                 :            :     }
     177                 :            :     printf("\n");
     178                 :            :     fflush(stdout);
     179                 :            :     PyErr_SetRaisedException(exc);
     180                 :            : }
     181                 :            : #endif
     182                 :            : static int call_trace(Py_tracefunc, PyObject *,
     183                 :            :                       PyThreadState *, _PyInterpreterFrame *,
     184                 :            :                       int, PyObject *);
     185                 :            : static int call_trace_protected(Py_tracefunc, PyObject *,
     186                 :            :                                 PyThreadState *, _PyInterpreterFrame *,
     187                 :            :                                 int, PyObject *);
     188                 :            : static void call_exc_trace(Py_tracefunc, PyObject *,
     189                 :            :                            PyThreadState *, _PyInterpreterFrame *);
     190                 :            : static int maybe_call_line_trace(Py_tracefunc, PyObject *,
     191                 :            :                                  PyThreadState *, _PyInterpreterFrame *, int);
     192                 :            : static void maybe_dtrace_line(_PyInterpreterFrame *, PyTraceInfo *, int);
     193                 :            : static void dtrace_function_entry(_PyInterpreterFrame *);
     194                 :            : static void dtrace_function_return(_PyInterpreterFrame *);
     195                 :            : 
     196                 :            : static PyObject * import_name(PyThreadState *, _PyInterpreterFrame *,
     197                 :            :                               PyObject *, PyObject *, PyObject *);
     198                 :            : static PyObject * import_from(PyThreadState *, PyObject *, PyObject *);
     199                 :            : static void format_exc_check_arg(PyThreadState *, PyObject *, const char *, PyObject *);
     200                 :            : static void format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg);
     201                 :            : static int check_args_iterable(PyThreadState *, PyObject *func, PyObject *vararg);
     202                 :            : static int check_except_type_valid(PyThreadState *tstate, PyObject* right);
     203                 :            : static int check_except_star_type_valid(PyThreadState *tstate, PyObject* right);
     204                 :            : static void format_kwargs_error(PyThreadState *, PyObject *func, PyObject *kwargs);
     205                 :            : static void format_awaitable_error(PyThreadState *, PyTypeObject *, int);
     206                 :            : static int get_exception_handler(PyCodeObject *, int, int*, int*, int*);
     207                 :            : static _PyInterpreterFrame *
     208                 :            : _PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,
     209                 :            :                         PyObject *locals, PyObject* const* args,
     210                 :            :                         size_t argcount, PyObject *kwnames);
     211                 :            : static void
     212                 :            : _PyEvalFrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame *frame);
     213                 :            : 
     214                 :            : #define UNBOUNDLOCAL_ERROR_MSG \
     215                 :            :     "cannot access local variable '%s' where it is not associated with a value"
     216                 :            : #define UNBOUNDFREE_ERROR_MSG \
     217                 :            :     "cannot access free variable '%s' where it is not associated with a" \
     218                 :            :     " value in enclosing scope"
     219                 :            : 
     220                 :            : #ifndef NDEBUG
     221                 :            : /* Ensure that tstate is valid: sanity check for PyEval_AcquireThread() and
     222                 :            :    PyEval_RestoreThread(). Detect if tstate memory was freed. It can happen
     223                 :            :    when a thread continues to run after Python finalization, especially
     224                 :            :    daemon threads. */
     225                 :            : static int
     226                 :            : is_tstate_valid(PyThreadState *tstate)
     227                 :            : {
     228                 :            :     assert(!_PyMem_IsPtrFreed(tstate));
     229                 :            :     assert(!_PyMem_IsPtrFreed(tstate->interp));
     230                 :            :     return 1;
     231                 :            : }
     232                 :            : #endif
     233                 :            : 
     234                 :            : 
     235                 :            : #ifdef HAVE_ERRNO_H
     236                 :            : #include <errno.h>
     237                 :            : #endif
     238                 :            : 
     239                 :            : int
     240                 :          0 : Py_GetRecursionLimit(void)
     241                 :            : {
     242                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
     243                 :          0 :     return interp->ceval.recursion_limit;
     244                 :            : }
     245                 :            : 
     246                 :            : void
     247                 :          0 : Py_SetRecursionLimit(int new_limit)
     248                 :            : {
     249                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
     250                 :          0 :     interp->ceval.recursion_limit = new_limit;
     251         [ #  # ]:          0 :     for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {
     252                 :          0 :         int depth = p->py_recursion_limit - p->py_recursion_remaining;
     253                 :          0 :         p->py_recursion_limit = new_limit;
     254                 :          0 :         p->py_recursion_remaining = new_limit - depth;
     255                 :            :     }
     256                 :          0 : }
     257                 :            : 
     258                 :            : /* The function _Py_EnterRecursiveCallTstate() only calls _Py_CheckRecursiveCall()
     259                 :            :    if the recursion_depth reaches recursion_limit. */
     260                 :            : int
     261                 :          0 : _Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)
     262                 :            : {
     263                 :            : #ifdef USE_STACKCHECK
     264                 :            :     if (PyOS_CheckStack()) {
     265                 :            :         ++tstate->c_recursion_remaining;
     266                 :            :         _PyErr_SetString(tstate, PyExc_MemoryError, "Stack overflow");
     267                 :            :         return -1;
     268                 :            :     }
     269                 :            : #endif
     270         [ #  # ]:          0 :     if (tstate->recursion_headroom) {
     271         [ #  # ]:          0 :         if (tstate->c_recursion_remaining < -50) {
     272                 :            :             /* Overflowing while handling an overflow. Give up. */
     273                 :          0 :             Py_FatalError("Cannot recover from stack overflow.");
     274                 :            :         }
     275                 :            :     }
     276                 :            :     else {
     277         [ #  # ]:          0 :         if (tstate->c_recursion_remaining <= 0) {
     278                 :          0 :             tstate->recursion_headroom++;
     279                 :          0 :             _PyErr_Format(tstate, PyExc_RecursionError,
     280                 :            :                         "maximum recursion depth exceeded%s",
     281                 :            :                         where);
     282                 :          0 :             tstate->recursion_headroom--;
     283                 :          0 :             ++tstate->c_recursion_remaining;
     284                 :          0 :             return -1;
     285                 :            :         }
     286                 :            :     }
     287                 :          0 :     return 0;
     288                 :            : }
     289                 :            : 
     290                 :            : 
     291                 :            : static const binaryfunc binary_ops[] = {
     292                 :            :     [NB_ADD] = PyNumber_Add,
     293                 :            :     [NB_AND] = PyNumber_And,
     294                 :            :     [NB_FLOOR_DIVIDE] = PyNumber_FloorDivide,
     295                 :            :     [NB_LSHIFT] = PyNumber_Lshift,
     296                 :            :     [NB_MATRIX_MULTIPLY] = PyNumber_MatrixMultiply,
     297                 :            :     [NB_MULTIPLY] = PyNumber_Multiply,
     298                 :            :     [NB_REMAINDER] = PyNumber_Remainder,
     299                 :            :     [NB_OR] = PyNumber_Or,
     300                 :            :     [NB_POWER] = _PyNumber_PowerNoMod,
     301                 :            :     [NB_RSHIFT] = PyNumber_Rshift,
     302                 :            :     [NB_SUBTRACT] = PyNumber_Subtract,
     303                 :            :     [NB_TRUE_DIVIDE] = PyNumber_TrueDivide,
     304                 :            :     [NB_XOR] = PyNumber_Xor,
     305                 :            :     [NB_INPLACE_ADD] = PyNumber_InPlaceAdd,
     306                 :            :     [NB_INPLACE_AND] = PyNumber_InPlaceAnd,
     307                 :            :     [NB_INPLACE_FLOOR_DIVIDE] = PyNumber_InPlaceFloorDivide,
     308                 :            :     [NB_INPLACE_LSHIFT] = PyNumber_InPlaceLshift,
     309                 :            :     [NB_INPLACE_MATRIX_MULTIPLY] = PyNumber_InPlaceMatrixMultiply,
     310                 :            :     [NB_INPLACE_MULTIPLY] = PyNumber_InPlaceMultiply,
     311                 :            :     [NB_INPLACE_REMAINDER] = PyNumber_InPlaceRemainder,
     312                 :            :     [NB_INPLACE_OR] = PyNumber_InPlaceOr,
     313                 :            :     [NB_INPLACE_POWER] = _PyNumber_InPlacePowerNoMod,
     314                 :            :     [NB_INPLACE_RSHIFT] = PyNumber_InPlaceRshift,
     315                 :            :     [NB_INPLACE_SUBTRACT] = PyNumber_InPlaceSubtract,
     316                 :            :     [NB_INPLACE_TRUE_DIVIDE] = PyNumber_InPlaceTrueDivide,
     317                 :            :     [NB_INPLACE_XOR] = PyNumber_InPlaceXor,
     318                 :            : };
     319                 :            : 
     320                 :            : 
     321                 :            : // PEP 634: Structural Pattern Matching
     322                 :            : 
     323                 :            : 
     324                 :            : // Return a tuple of values corresponding to keys, with error checks for
     325                 :            : // duplicate/missing keys.
     326                 :            : static PyObject*
     327                 :          0 : match_keys(PyThreadState *tstate, PyObject *map, PyObject *keys)
     328                 :            : {
     329                 :            :     assert(PyTuple_CheckExact(keys));
     330                 :          0 :     Py_ssize_t nkeys = PyTuple_GET_SIZE(keys);
     331         [ #  # ]:          0 :     if (!nkeys) {
     332                 :            :         // No keys means no items.
     333                 :          0 :         return PyTuple_New(0);
     334                 :            :     }
     335                 :          0 :     PyObject *seen = NULL;
     336                 :          0 :     PyObject *dummy = NULL;
     337                 :          0 :     PyObject *values = NULL;
     338                 :          0 :     PyObject *get = NULL;
     339                 :            :     // We use the two argument form of map.get(key, default) for two reasons:
     340                 :            :     // - Atomically check for a key and get its value without error handling.
     341                 :            :     // - Don't cause key creation or resizing in dict subclasses like
     342                 :            :     //   collections.defaultdict that define __missing__ (or similar).
     343                 :          0 :     int meth_found = _PyObject_GetMethod(map, &_Py_ID(get), &get);
     344         [ #  # ]:          0 :     if (get == NULL) {
     345                 :          0 :         goto fail;
     346                 :            :     }
     347                 :          0 :     seen = PySet_New(NULL);
     348         [ #  # ]:          0 :     if (seen == NULL) {
     349                 :          0 :         goto fail;
     350                 :            :     }
     351                 :            :     // dummy = object()
     352                 :          0 :     dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);
     353         [ #  # ]:          0 :     if (dummy == NULL) {
     354                 :          0 :         goto fail;
     355                 :            :     }
     356                 :          0 :     values = PyTuple_New(nkeys);
     357         [ #  # ]:          0 :     if (values == NULL) {
     358                 :          0 :         goto fail;
     359                 :            :     }
     360         [ #  # ]:          0 :     for (Py_ssize_t i = 0; i < nkeys; i++) {
     361                 :          0 :         PyObject *key = PyTuple_GET_ITEM(keys, i);
     362   [ #  #  #  # ]:          0 :         if (PySet_Contains(seen, key) || PySet_Add(seen, key)) {
     363         [ #  # ]:          0 :             if (!_PyErr_Occurred(tstate)) {
     364                 :            :                 // Seen it before!
     365                 :          0 :                 _PyErr_Format(tstate, PyExc_ValueError,
     366                 :            :                               "mapping pattern checks duplicate key (%R)", key);
     367                 :            :             }
     368                 :          0 :             goto fail;
     369                 :            :         }
     370                 :          0 :         PyObject *args[] = { map, key, dummy };
     371                 :          0 :         PyObject *value = NULL;
     372         [ #  # ]:          0 :         if (meth_found) {
     373                 :          0 :             value = PyObject_Vectorcall(get, args, 3, NULL);
     374                 :            :         }
     375                 :            :         else {
     376                 :          0 :             value = PyObject_Vectorcall(get, &args[1], 2, NULL);
     377                 :            :         }
     378         [ #  # ]:          0 :         if (value == NULL) {
     379                 :          0 :             goto fail;
     380                 :            :         }
     381         [ #  # ]:          0 :         if (value == dummy) {
     382                 :            :             // key not in map!
     383         [ #  # ]:          0 :             Py_DECREF(value);
     384         [ #  # ]:          0 :             Py_DECREF(values);
     385                 :            :             // Return None:
     386                 :          0 :             values = Py_NewRef(Py_None);
     387                 :          0 :             goto done;
     388                 :            :         }
     389                 :          0 :         PyTuple_SET_ITEM(values, i, value);
     390                 :            :     }
     391                 :            :     // Success:
     392                 :          0 : done:
     393         [ #  # ]:          0 :     Py_DECREF(get);
     394         [ #  # ]:          0 :     Py_DECREF(seen);
     395         [ #  # ]:          0 :     Py_DECREF(dummy);
     396                 :          0 :     return values;
     397                 :          0 : fail:
     398   [ #  #  #  # ]:          0 :     Py_XDECREF(get);
     399   [ #  #  #  # ]:          0 :     Py_XDECREF(seen);
     400   [ #  #  #  # ]:          0 :     Py_XDECREF(dummy);
     401   [ #  #  #  # ]:          0 :     Py_XDECREF(values);
     402                 :          0 :     return NULL;
     403                 :            : }
     404                 :            : 
     405                 :            : // Extract a named attribute from the subject, with additional bookkeeping to
     406                 :            : // raise TypeErrors for repeated lookups. On failure, return NULL (with no
     407                 :            : // error set). Use _PyErr_Occurred(tstate) to disambiguate.
     408                 :            : static PyObject*
     409                 :          9 : match_class_attr(PyThreadState *tstate, PyObject *subject, PyObject *type,
     410                 :            :                  PyObject *name, PyObject *seen)
     411                 :            : {
     412                 :            :     assert(PyUnicode_CheckExact(name));
     413                 :            :     assert(PySet_CheckExact(seen));
     414   [ +  -  -  + ]:          9 :     if (PySet_Contains(seen, name) || PySet_Add(seen, name)) {
     415         [ #  # ]:          0 :         if (!_PyErr_Occurred(tstate)) {
     416                 :            :             // Seen it before!
     417                 :          0 :             _PyErr_Format(tstate, PyExc_TypeError,
     418                 :            :                           "%s() got multiple sub-patterns for attribute %R",
     419                 :            :                           ((PyTypeObject*)type)->tp_name, name);
     420                 :            :         }
     421                 :          0 :         return NULL;
     422                 :            :     }
     423                 :          9 :     PyObject *attr = PyObject_GetAttr(subject, name);
     424   [ -  +  -  - ]:          9 :     if (attr == NULL && _PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
     425                 :          0 :         _PyErr_Clear(tstate);
     426                 :            :     }
     427                 :          9 :     return attr;
     428                 :            : }
     429                 :            : 
     430                 :            : // On success (match), return a tuple of extracted attributes. On failure (no
     431                 :            : // match), return NULL. Use _PyErr_Occurred(tstate) to disambiguate.
     432                 :            : static PyObject*
     433                 :         26 : match_class(PyThreadState *tstate, PyObject *subject, PyObject *type,
     434                 :            :             Py_ssize_t nargs, PyObject *kwargs)
     435                 :            : {
     436         [ -  + ]:         26 :     if (!PyType_Check(type)) {
     437                 :          0 :         const char *e = "called match pattern must be a type";
     438                 :          0 :         _PyErr_Format(tstate, PyExc_TypeError, e);
     439                 :          0 :         return NULL;
     440                 :            :     }
     441                 :            :     assert(PyTuple_CheckExact(kwargs));
     442                 :            :     // First, an isinstance check:
     443         [ +  + ]:         26 :     if (PyObject_IsInstance(subject, type) <= 0) {
     444                 :         16 :         return NULL;
     445                 :            :     }
     446                 :            :     // So far so good:
     447                 :         10 :     PyObject *seen = PySet_New(NULL);
     448         [ -  + ]:         10 :     if (seen == NULL) {
     449                 :          0 :         return NULL;
     450                 :            :     }
     451                 :         10 :     PyObject *attrs = PyList_New(0);
     452         [ -  + ]:         10 :     if (attrs == NULL) {
     453         [ #  # ]:          0 :         Py_DECREF(seen);
     454                 :          0 :         return NULL;
     455                 :            :     }
     456                 :            :     // NOTE: From this point on, goto fail on failure:
     457                 :         10 :     PyObject *match_args = NULL;
     458                 :            :     // First, the positional subpatterns:
     459         [ +  + ]:         10 :     if (nargs) {
     460                 :          9 :         int match_self = 0;
     461                 :          9 :         match_args = PyObject_GetAttrString(type, "__match_args__");
     462         [ +  - ]:          9 :         if (match_args) {
     463         [ -  + ]:          9 :             if (!PyTuple_CheckExact(match_args)) {
     464                 :          0 :                 const char *e = "%s.__match_args__ must be a tuple (got %s)";
     465                 :          0 :                 _PyErr_Format(tstate, PyExc_TypeError, e,
     466                 :            :                               ((PyTypeObject *)type)->tp_name,
     467                 :          0 :                               Py_TYPE(match_args)->tp_name);
     468                 :          0 :                 goto fail;
     469                 :            :             }
     470                 :            :         }
     471         [ #  # ]:          0 :         else if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
     472                 :          0 :             _PyErr_Clear(tstate);
     473                 :            :             // _Py_TPFLAGS_MATCH_SELF is only acknowledged if the type does not
     474                 :            :             // define __match_args__. This is natural behavior for subclasses:
     475                 :            :             // it's as if __match_args__ is some "magic" value that is lost as
     476                 :            :             // soon as they redefine it.
     477                 :          0 :             match_args = PyTuple_New(0);
     478                 :          0 :             match_self = PyType_HasFeature((PyTypeObject*)type,
     479                 :            :                                             _Py_TPFLAGS_MATCH_SELF);
     480                 :            :         }
     481                 :            :         else {
     482                 :          0 :             goto fail;
     483                 :            :         }
     484                 :            :         assert(PyTuple_CheckExact(match_args));
     485         [ +  - ]:          9 :         Py_ssize_t allowed = match_self ? 1 : PyTuple_GET_SIZE(match_args);
     486         [ -  + ]:          9 :         if (allowed < nargs) {
     487         [ #  # ]:          0 :             const char *plural = (allowed == 1) ? "" : "s";
     488                 :          0 :             _PyErr_Format(tstate, PyExc_TypeError,
     489                 :            :                           "%s() accepts %d positional sub-pattern%s (%d given)",
     490                 :            :                           ((PyTypeObject*)type)->tp_name,
     491                 :            :                           allowed, plural, nargs);
     492                 :          0 :             goto fail;
     493                 :            :         }
     494         [ -  + ]:          9 :         if (match_self) {
     495                 :            :             // Easy. Copy the subject itself, and move on to kwargs.
     496                 :          0 :             PyList_Append(attrs, subject);
     497                 :            :         }
     498                 :            :         else {
     499         [ +  + ]:         18 :             for (Py_ssize_t i = 0; i < nargs; i++) {
     500                 :          9 :                 PyObject *name = PyTuple_GET_ITEM(match_args, i);
     501         [ -  + ]:          9 :                 if (!PyUnicode_CheckExact(name)) {
     502                 :          0 :                     _PyErr_Format(tstate, PyExc_TypeError,
     503                 :            :                                   "__match_args__ elements must be strings "
     504                 :          0 :                                   "(got %s)", Py_TYPE(name)->tp_name);
     505                 :          0 :                     goto fail;
     506                 :            :                 }
     507                 :          9 :                 PyObject *attr = match_class_attr(tstate, subject, type, name,
     508                 :            :                                                   seen);
     509         [ -  + ]:          9 :                 if (attr == NULL) {
     510                 :          0 :                     goto fail;
     511                 :            :                 }
     512                 :          9 :                 PyList_Append(attrs, attr);
     513         [ -  + ]:          9 :                 Py_DECREF(attr);
     514                 :            :             }
     515                 :            :         }
     516   [ +  -  -  + ]:          9 :         Py_CLEAR(match_args);
     517                 :            :     }
     518                 :            :     // Finally, the keyword subpatterns:
     519         [ -  + ]:         10 :     for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(kwargs); i++) {
     520                 :          0 :         PyObject *name = PyTuple_GET_ITEM(kwargs, i);
     521                 :          0 :         PyObject *attr = match_class_attr(tstate, subject, type, name, seen);
     522         [ #  # ]:          0 :         if (attr == NULL) {
     523                 :          0 :             goto fail;
     524                 :            :         }
     525                 :          0 :         PyList_Append(attrs, attr);
     526         [ #  # ]:          0 :         Py_DECREF(attr);
     527                 :            :     }
     528         [ +  - ]:         10 :     Py_SETREF(attrs, PyList_AsTuple(attrs));
     529         [ +  - ]:         10 :     Py_DECREF(seen);
     530                 :         10 :     return attrs;
     531                 :          0 : fail:
     532                 :            :     // We really don't care whether an error was raised or not... that's our
     533                 :            :     // caller's problem. All we know is that the match failed.
     534   [ #  #  #  # ]:          0 :     Py_XDECREF(match_args);
     535         [ #  # ]:          0 :     Py_DECREF(seen);
     536         [ #  # ]:          0 :     Py_DECREF(attrs);
     537                 :          0 :     return NULL;
     538                 :            : }
     539                 :            : 
     540                 :            : 
     541                 :            : static int do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause);
     542                 :            : static int exception_group_match(
     543                 :            :     PyObject* exc_value, PyObject *match_type,
     544                 :            :     PyObject **match, PyObject **rest);
     545                 :            : 
     546                 :            : static int unpack_iterable(PyThreadState *, PyObject *, int, int, PyObject **);
     547                 :            : 
     548                 :            : PyObject *
     549                 :        828 : PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
     550                 :            : {
     551                 :        828 :     PyThreadState *tstate = _PyThreadState_GET();
     552         [ -  + ]:        828 :     if (locals == NULL) {
     553                 :          0 :         locals = globals;
     554                 :            :     }
     555                 :        828 :     PyObject *builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref
     556         [ -  + ]:        828 :     if (builtins == NULL) {
     557                 :          0 :         return NULL;
     558                 :            :     }
     559                 :        828 :     PyFrameConstructor desc = {
     560                 :            :         .fc_globals = globals,
     561                 :            :         .fc_builtins = builtins,
     562                 :        828 :         .fc_name = ((PyCodeObject *)co)->co_name,
     563                 :        828 :         .fc_qualname = ((PyCodeObject *)co)->co_name,
     564                 :            :         .fc_code = co,
     565                 :            :         .fc_defaults = NULL,
     566                 :            :         .fc_kwdefaults = NULL,
     567                 :            :         .fc_closure = NULL
     568                 :            :     };
     569                 :        828 :     PyFunctionObject *func = _PyFunction_FromConstructor(&desc);
     570         [ -  + ]:        828 :     if (func == NULL) {
     571                 :          0 :         return NULL;
     572                 :            :     }
     573                 :            :     EVAL_CALL_STAT_INC(EVAL_CALL_LEGACY);
     574                 :        828 :     PyObject *res = _PyEval_Vector(tstate, func, locals, NULL, 0, NULL);
     575         [ +  + ]:        828 :     Py_DECREF(func);
     576                 :        828 :     return res;
     577                 :            : }
     578                 :            : 
     579                 :            : 
     580                 :            : /* Interpreter main loop */
     581                 :            : 
     582                 :            : PyObject *
     583                 :          0 : PyEval_EvalFrame(PyFrameObject *f)
     584                 :            : {
     585                 :            :     /* Function kept for backward compatibility */
     586                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
     587                 :          0 :     return _PyEval_EvalFrame(tstate, f->f_frame, 0);
     588                 :            : }
     589                 :            : 
     590                 :            : PyObject *
     591                 :          0 : PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)
     592                 :            : {
     593                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
     594                 :          0 :     return _PyEval_EvalFrame(tstate, f->f_frame, throwflag);
     595                 :            : }
     596                 :            : 
     597                 :            : #include "ceval_macros.h"
     598                 :            : 
     599                 :            : static int
     600                 :          0 : trace_function_entry(PyThreadState *tstate, _PyInterpreterFrame *frame)
     601                 :            : {
     602         [ #  # ]:          0 :     if (tstate->c_tracefunc != NULL) {
     603                 :            :         /* tstate->c_tracefunc, if defined, is a
     604                 :            :             function that will be called on *every* entry
     605                 :            :             to a code block.  Its return value, if not
     606                 :            :             None, is a function that will be called at
     607                 :            :             the start of each executed line of code.
     608                 :            :             (Actually, the function must return itself
     609                 :            :             in order to continue tracing.)  The trace
     610                 :            :             functions are called with three arguments:
     611                 :            :             a pointer to the current frame, a string
     612                 :            :             indicating why the function is called, and
     613                 :            :             an argument which depends on the situation.
     614                 :            :             The global trace function is also called
     615                 :            :             whenever an exception is detected. */
     616         [ #  # ]:          0 :         if (call_trace_protected(tstate->c_tracefunc,
     617                 :            :                                     tstate->c_traceobj,
     618                 :            :                                     tstate, frame,
     619                 :            :                                     PyTrace_CALL, Py_None)) {
     620                 :            :             /* Trace function raised an error */
     621                 :          0 :             return -1;
     622                 :            :         }
     623                 :            :     }
     624         [ #  # ]:          0 :     if (tstate->c_profilefunc != NULL) {
     625                 :            :         /* Similar for c_profilefunc, except it needn't
     626                 :            :             return itself and isn't called for "line" events */
     627         [ #  # ]:          0 :         if (call_trace_protected(tstate->c_profilefunc,
     628                 :            :                                     tstate->c_profileobj,
     629                 :            :                                     tstate, frame,
     630                 :            :                                     PyTrace_CALL, Py_None)) {
     631                 :            :             /* Profile function raised an error */
     632                 :          0 :             return -1;
     633                 :            :         }
     634                 :            :     }
     635                 :          0 :     return 0;
     636                 :            : }
     637                 :            : 
     638                 :            : static int
     639                 :          0 : trace_function_exit(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObject *retval)
     640                 :            : {
     641         [ #  # ]:          0 :     if (tstate->c_tracefunc) {
     642         [ #  # ]:          0 :         if (call_trace_protected(tstate->c_tracefunc, tstate->c_traceobj,
     643                 :            :                                     tstate, frame, PyTrace_RETURN, retval)) {
     644                 :          0 :             return -1;
     645                 :            :         }
     646                 :            :     }
     647         [ #  # ]:          0 :     if (tstate->c_profilefunc) {
     648         [ #  # ]:          0 :         if (call_trace_protected(tstate->c_profilefunc, tstate->c_profileobj,
     649                 :            :                                     tstate, frame, PyTrace_RETURN, retval)) {
     650                 :          0 :             return -1;
     651                 :            :         }
     652                 :            :     }
     653                 :          0 :     return 0;
     654                 :            : }
     655                 :            : 
     656                 :            : 
     657                 :          0 : int _Py_CheckRecursiveCallPy(
     658                 :            :     PyThreadState *tstate)
     659                 :            : {
     660         [ #  # ]:          0 :     if (tstate->recursion_headroom) {
     661         [ #  # ]:          0 :         if (tstate->py_recursion_remaining < -50) {
     662                 :            :             /* Overflowing while handling an overflow. Give up. */
     663                 :          0 :             Py_FatalError("Cannot recover from Python stack overflow.");
     664                 :            :         }
     665                 :            :     }
     666                 :            :     else {
     667         [ #  # ]:          0 :         if (tstate->py_recursion_remaining <= 0) {
     668                 :          0 :             tstate->recursion_headroom++;
     669                 :          0 :             _PyErr_Format(tstate, PyExc_RecursionError,
     670                 :            :                         "maximum recursion depth exceeded");
     671                 :          0 :             tstate->recursion_headroom--;
     672                 :          0 :             return -1;
     673                 :            :         }
     674                 :            :     }
     675                 :          0 :     return 0;
     676                 :            : }
     677                 :            : 
     678                 :    4159852 : static inline int _Py_EnterRecursivePy(PyThreadState *tstate) {
     679   [ -  +  -  - ]:    4159852 :     return (tstate->py_recursion_remaining-- <= 0) &&
     680                 :          0 :         _Py_CheckRecursiveCallPy(tstate);
     681                 :            : }
     682                 :            : 
     683                 :            : 
     684                 :    4159852 : static inline void _Py_LeaveRecursiveCallPy(PyThreadState *tstate)  {
     685                 :    4159852 :     tstate->py_recursion_remaining++;
     686                 :    4159852 : }
     687                 :            : 
     688                 :            : 
     689                 :            : /* Disable unused label warnings.  They are handy for debugging, even
     690                 :            :    if computed gotos aren't used. */
     691                 :            : 
     692                 :            : /* TBD - what about other compilers? */
     693                 :            : #if defined(__GNUC__)
     694                 :            : #  pragma GCC diagnostic push
     695                 :            : #  pragma GCC diagnostic ignored "-Wunused-label"
     696                 :            : #elif defined(_MSC_VER) /* MS_WINDOWS */
     697                 :            : #  pragma warning(push)
     698                 :            : #  pragma warning(disable:4102)
     699                 :            : #endif
     700                 :            : 
     701                 :            : PyObject* _Py_HOT_FUNCTION
     702                 :    1676264 : _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag)
     703                 :            : {
     704                 :    1676264 :     _Py_EnsureTstateNotNULL(tstate);
     705                 :            :     CALL_STAT_INC(pyeval_calls);
     706                 :            : 
     707                 :            : #if USE_COMPUTED_GOTOS
     708                 :            : /* Import the static jump table */
     709                 :            : #include "opcode_targets.h"
     710                 :            : #endif
     711                 :            : 
     712                 :            : #ifdef Py_STATS
     713                 :            :     int lastopcode = 0;
     714                 :            : #endif
     715                 :            :     // opcode is an 8-bit value to improve the code generated by MSVC
     716                 :            :     // for the big switch below (in combination with the EXTRA_CASES macro).
     717                 :            :     uint8_t opcode;        /* Current opcode */
     718                 :            :     int oparg;         /* Current opcode argument, if any */
     719                 :    1676264 :     _Py_atomic_int * const eval_breaker = &tstate->interp->ceval.eval_breaker;
     720                 :            : #ifdef LLTRACE
     721                 :            :     int lltrace = 0;
     722                 :            : #endif
     723                 :            : 
     724                 :            :     _PyCFrame cframe;
     725                 :            :     _PyInterpreterFrame  entry_frame;
     726                 :    1676264 :     PyObject *kwnames = NULL; // Borrowed reference. Reset by CALL instructions.
     727                 :            : 
     728                 :            :     /* WARNING: Because the _PyCFrame lives on the C stack,
     729                 :            :      * but can be accessed from a heap allocated object (tstate)
     730                 :            :      * strict stack discipline must be maintained.
     731                 :            :      */
     732                 :    1676264 :     _PyCFrame *prev_cframe = tstate->cframe;
     733                 :    1676264 :     cframe.use_tracing = prev_cframe->use_tracing;
     734                 :    1676264 :     cframe.previous = prev_cframe;
     735                 :    1676264 :     tstate->cframe = &cframe;
     736                 :            : 
     737                 :            :     assert(tstate->interp->interpreter_trampoline != NULL);
     738                 :            : #ifdef Py_DEBUG
     739                 :            :     /* Set these to invalid but identifiable values for debugging. */
     740                 :            :     entry_frame.f_funcobj = (PyObject*)0xaaa0;
     741                 :            :     entry_frame.f_locals = (PyObject*)0xaaa1;
     742                 :            :     entry_frame.frame_obj = (PyFrameObject*)0xaaa2;
     743                 :            :     entry_frame.f_globals = (PyObject*)0xaaa3;
     744                 :            :     entry_frame.f_builtins = (PyObject*)0xaaa4;
     745                 :            : #endif
     746                 :    1676264 :     entry_frame.f_code = tstate->interp->interpreter_trampoline;
     747                 :    1676264 :     entry_frame.prev_instr =
     748                 :    1676264 :         _PyCode_CODE(tstate->interp->interpreter_trampoline);
     749                 :    1676264 :     entry_frame.stacktop = 0;
     750                 :    1676264 :     entry_frame.owner = FRAME_OWNED_BY_CSTACK;
     751                 :    1676264 :     entry_frame.yield_offset = 0;
     752                 :            :     /* Push frame */
     753                 :    1676264 :     entry_frame.previous = prev_cframe->current_frame;
     754                 :    1676264 :     frame->previous = &entry_frame;
     755                 :    1676264 :     cframe.current_frame = frame;
     756                 :            : 
     757         [ -  + ]:    1676264 :     if (_Py_EnterRecursiveCallTstate(tstate, "")) {
     758                 :          0 :         tstate->c_recursion_remaining--;
     759                 :          0 :         tstate->py_recursion_remaining--;
     760                 :          0 :         goto exit_unwind;
     761                 :            :     }
     762                 :            : 
     763                 :            :     /* support for generator.throw() */
     764         [ +  + ]:    1676264 :     if (throwflag) {
     765         [ -  + ]:       1937 :         if (_Py_EnterRecursivePy(tstate)) {
     766                 :          0 :             goto exit_unwind;
     767                 :            :         }
     768   [ -  +  -  - ]:       1937 :         TRACE_FUNCTION_THROW_ENTRY();
     769         [ -  + ]:       1937 :         DTRACE_FUNCTION_ENTRY();
     770                 :       1937 :         goto resume_with_error;
     771                 :            :     }
     772                 :            : 
     773                 :            :     /* Local "register" variables.
     774                 :            :      * These are cached values from the frame and code object.  */
     775                 :            : 
     776                 :            :     _Py_CODEUNIT *next_instr;
     777                 :            :     PyObject **stack_pointer;
     778                 :            : 
     779                 :            : /* Sets the above local variables from the frame */
     780                 :            : #define SET_LOCALS_FROM_FRAME() \
     781                 :            :     assert(_PyInterpreterFrame_LASTI(frame) >= -1); \
     782                 :            :     /* Jump back to the last instruction executed... */ \
     783                 :            :     next_instr = frame->prev_instr + 1; \
     784                 :            :     stack_pointer = _PyFrame_GetStackPointer(frame); \
     785                 :            :     /* Set stackdepth to -1. \
     786                 :            :         Update when returning or calling trace function. \
     787                 :            :         Having stackdepth <= 0 ensures that invalid \
     788                 :            :         values are not visible to the cycle GC. \
     789                 :            :         We choose -1 rather than 0 to assist debugging. \
     790                 :            :         */ \
     791                 :            :     frame->stacktop = -1;
     792                 :            : 
     793                 :            : 
     794                 :    1674327 : start_frame:
     795         [ -  + ]:    4157915 :     if (_Py_EnterRecursivePy(tstate)) {
     796                 :          0 :         goto exit_unwind;
     797                 :            :     }
     798                 :            : 
     799                 :    4157915 : resume_frame:
     800                 :    8314308 :     SET_LOCALS_FROM_FRAME();
     801                 :            : 
     802                 :            : #ifdef LLTRACE
     803                 :            :     {
     804                 :            :         if (frame != &entry_frame) {
     805                 :            :             int r = PyDict_Contains(GLOBALS(), &_Py_ID(__lltrace__));
     806                 :            :             if (r < 0) {
     807                 :            :                 goto exit_unwind;
     808                 :            :             }
     809                 :            :             lltrace = r;
     810                 :            :         }
     811                 :            :         if (lltrace) {
     812                 :            :             lltrace_resume_frame(frame);
     813                 :            :         }
     814                 :            :     }
     815                 :            : #endif
     816                 :            : 
     817                 :            : #ifdef Py_DEBUG
     818                 :            :     /* _PyEval_EvalFrameDefault() must not be called with an exception set,
     819                 :            :        because it can clear it (directly or indirectly) and so the
     820                 :            :        caller loses its exception */
     821                 :            :     assert(!_PyErr_Occurred(tstate));
     822                 :            : #endif
     823                 :            : 
     824                 :    8314308 :     DISPATCH();
     825                 :            : 
     826                 :        298 : handle_eval_breaker:
     827                 :            : 
     828                 :            :     /* Do periodic things, like check for signals and async I/0.
     829                 :            :      * We need to do reasonably frequently, but not too frequently.
     830                 :            :      * All loops should include a check of the eval breaker.
     831                 :            :      * We also check on return from any builtin function.
     832                 :            :      */
     833         [ -  + ]:        298 :     if (_Py_HandlePending(tstate) != 0) {
     834                 :          0 :         goto error;
     835                 :            :     }
     836                 :        298 :     DISPATCH();
     837                 :            : 
     838                 :            :     {
     839                 :            :     /* Start instructions */
     840                 :            : #if !USE_COMPUTED_GOTOS
     841                 :            :     dispatch_opcode:
     842                 :            :         switch (opcode)
     843                 :            : #endif
     844                 :            :         {
     845                 :            : 
     846                 :            : #include "generated_cases.c.h"
     847                 :            : 
     848                 :            : #if USE_COMPUTED_GOTOS
     849                 :          0 :         TARGET_DO_TRACING:
     850                 :            : #else
     851                 :            :         case DO_TRACING:
     852                 :            : #endif
     853                 :            :     {
     854                 :            :         assert(cframe.use_tracing);
     855                 :            :         assert(tstate->tracing == 0);
     856         [ #  # ]:          0 :         if (INSTR_OFFSET() >= frame->f_code->_co_firsttraceable) {
     857                 :          0 :             int instr_prev = _PyInterpreterFrame_LASTI(frame);
     858                 :          0 :             frame->prev_instr = next_instr;
     859                 :          0 :             NEXTOPARG();
     860                 :            :             // No _PyOpcode_Deopt here, since RESUME has no optimized forms:
     861         [ #  # ]:          0 :             if (opcode == RESUME) {
     862         [ #  # ]:          0 :                 if (oparg < 2) {
     863         [ #  # ]:          0 :                     CHECK_EVAL_BREAKER();
     864                 :            :                 }
     865                 :            :                 /* Call tracing */
     866   [ #  #  #  # ]:          0 :                 TRACE_FUNCTION_ENTRY();
     867         [ #  # ]:          0 :                 DTRACE_FUNCTION_ENTRY();
     868                 :            :             }
     869                 :            :             else {
     870                 :            :                 /* line-by-line tracing support */
     871         [ #  # ]:          0 :                 if (PyDTrace_LINE_ENABLED()) {
     872                 :          0 :                     maybe_dtrace_line(frame, &tstate->trace_info, instr_prev);
     873                 :            :                 }
     874                 :            : 
     875         [ #  # ]:          0 :                 if (cframe.use_tracing &&
     876   [ #  #  #  # ]:          0 :                     tstate->c_tracefunc != NULL && !tstate->tracing) {
     877                 :            :                     int err;
     878                 :            :                     /* see maybe_call_line_trace()
     879                 :            :                     for expository comments */
     880                 :          0 :                     _PyFrame_SetStackPointer(frame, stack_pointer);
     881                 :            : 
     882                 :          0 :                     err = maybe_call_line_trace(tstate->c_tracefunc,
     883                 :            :                                                 tstate->c_traceobj,
     884                 :            :                                                 tstate, frame, instr_prev);
     885                 :            :                     // Reload possibly changed frame fields:
     886                 :          0 :                     stack_pointer = _PyFrame_GetStackPointer(frame);
     887                 :          0 :                     frame->stacktop = -1;
     888                 :            :                     // next_instr is only reloaded if tracing *does not* raise.
     889                 :            :                     // This is consistent with the behavior of older Python
     890                 :            :                     // versions. If a trace function sets a new f_lineno and
     891                 :            :                     // *then* raises, we use the *old* location when searching
     892                 :            :                     // for an exception handler, displaying the traceback, and
     893                 :            :                     // so on:
     894         [ #  # ]:          0 :                     if (err) {
     895                 :            :                         // next_instr wasn't incremented at the start of this
     896                 :            :                         // instruction. Increment it before handling the error,
     897                 :            :                         // so that it looks the same as a "normal" instruction:
     898                 :          0 :                         next_instr++;
     899                 :          0 :                         goto error;
     900                 :            :                     }
     901                 :            :                     // Reload next_instr. Don't increment it, though, since
     902                 :            :                     // we're going to re-dispatch to the "true" instruction now:
     903                 :          0 :                     next_instr = frame->prev_instr;
     904                 :            :                 }
     905                 :            :             }
     906                 :            :         }
     907                 :          0 :         NEXTOPARG();
     908                 :            :         PRE_DISPATCH_GOTO();
     909                 :            :         // No _PyOpcode_Deopt here, since EXTENDED_ARG has no optimized forms:
     910         [ #  # ]:          0 :         while (opcode == EXTENDED_ARG) {
     911                 :            :             // CPython hasn't ever traced the instruction after an EXTENDED_ARG.
     912                 :            :             // Inline the EXTENDED_ARG here, so we can avoid branching there:
     913                 :          0 :             INSTRUCTION_START(EXTENDED_ARG);
     914                 :          0 :             opcode = next_instr->op.code;
     915                 :          0 :             oparg = oparg << 8 | next_instr->op.arg;
     916                 :            :             // Make sure the next instruction isn't a RESUME, since that needs
     917                 :            :             // to trace properly (and shouldn't have an EXTENDED_ARG, anyways):
     918                 :            :             assert(opcode != RESUME);
     919                 :            :             PRE_DISPATCH_GOTO();
     920                 :            :         }
     921                 :          0 :         opcode = _PyOpcode_Deopt[opcode];
     922         [ #  # ]:          0 :         if (_PyOpcode_Caches[opcode]) {
     923                 :          0 :             uint16_t *counter = &next_instr[1].cache;
     924                 :            :             // The instruction is going to decrement the counter, so we need to
     925                 :            :             // increment it here to make sure it doesn't try to specialize:
     926         [ #  # ]:          0 :             if (!ADAPTIVE_COUNTER_IS_MAX(*counter)) {
     927                 :          0 :                 INCREMENT_ADAPTIVE_COUNTER(*counter);
     928                 :            :             }
     929                 :            :         }
     930                 :          0 :         DISPATCH_GOTO();
     931                 :            :     }
     932                 :            : 
     933                 :            : #if USE_COMPUTED_GOTOS
     934                 :          0 :         _unknown_opcode:
     935                 :            : #else
     936                 :            :         EXTRA_CASES  // From opcode.h, a 'case' for each unused opcode
     937                 :            : #endif
     938                 :            :             /* Tell C compilers not to hold the opcode variable in the loop.
     939                 :            :                next_instr points the current instruction without TARGET(). */
     940                 :          0 :             opcode = next_instr->op.code;
     941                 :          0 :             _PyErr_Format(tstate, PyExc_SystemError,
     942                 :            :                           "%U:%d: unknown opcode %d",
     943                 :          0 :                           frame->f_code->co_filename,
     944                 :            :                           _PyInterpreterFrame_GetLine(frame),
     945                 :            :                           opcode);
     946                 :          0 :             goto error;
     947                 :            : 
     948                 :            :         } /* End instructions */
     949                 :            : 
     950                 :            :         /* This should never be reached. Every opcode should end with DISPATCH()
     951                 :            :            or goto error. */
     952                 :            :         Py_UNREACHABLE();
     953                 :            : 
     954                 :          0 : unbound_local_error:
     955                 :            :         {
     956                 :          0 :             format_exc_check_arg(tstate, PyExc_UnboundLocalError,
     957                 :            :                 UNBOUNDLOCAL_ERROR_MSG,
     958                 :          0 :                 PyTuple_GetItem(frame->f_code->co_localsplusnames, oparg)
     959                 :            :             );
     960                 :          0 :             goto error;
     961                 :            :         }
     962                 :            : 
     963                 :          0 : pop_4_error:
     964                 :          0 :     STACK_SHRINK(1);
     965                 :        204 : pop_3_error:
     966                 :        204 :     STACK_SHRINK(1);
     967                 :     101703 : pop_2_error:
     968                 :     101703 :     STACK_SHRINK(1);
     969                 :     102187 : pop_1_error:
     970                 :     102187 :     STACK_SHRINK(1);
     971                 :     105269 : error:
     972                 :     105269 :         kwnames = NULL;
     973                 :            :         /* Double-check exception status. */
     974                 :            : #ifdef NDEBUG
     975         [ -  + ]:     105269 :         if (!_PyErr_Occurred(tstate)) {
     976                 :          0 :             _PyErr_SetString(tstate, PyExc_SystemError,
     977                 :            :                              "error return without exception set");
     978                 :            :         }
     979                 :            : #else
     980                 :            :         assert(_PyErr_Occurred(tstate));
     981                 :            : #endif
     982                 :            : 
     983                 :            :         /* Log traceback info. */
     984                 :            :         assert(frame != &entry_frame);
     985         [ +  - ]:     105269 :         if (!_PyFrame_IsIncomplete(frame)) {
     986                 :     105269 :             PyFrameObject *f = _PyFrame_GetFrameObject(frame);
     987         [ +  - ]:     105269 :             if (f != NULL) {
     988                 :     105269 :                 PyTraceBack_Here(f);
     989                 :            :             }
     990                 :            :         }
     991                 :            : 
     992         [ +  - ]:     105269 :         if (tstate->c_tracefunc != NULL) {
     993                 :            :             /* Make sure state is set to FRAME_UNWINDING for tracing */
     994                 :          0 :             call_exc_trace(tstate->c_tracefunc, tstate->c_traceobj,
     995                 :            :                            tstate, frame);
     996                 :            :         }
     997                 :            : 
     998                 :     105269 : exception_unwind:
     999                 :            :         {
    1000                 :            :             /* We can't use frame->f_lasti here, as RERAISE may have set it */
    1001                 :     107686 :             int offset = INSTR_OFFSET()-1;
    1002                 :            :             int level, handler, lasti;
    1003         [ +  + ]:     107686 :             if (get_exception_handler(frame->f_code, offset, &level, &handler, &lasti) == 0) {
    1004                 :            :                 // No handlers, so exit.
    1005                 :            :                 assert(_PyErr_Occurred(tstate));
    1006                 :            : 
    1007                 :            :                 /* Pop remaining stack entries. */
    1008                 :       3459 :                 PyObject **stackbase = _PyFrame_Stackbase(frame);
    1009         [ +  + ]:       8067 :                 while (stack_pointer > stackbase) {
    1010                 :       4608 :                     PyObject *o = POP();
    1011   [ +  -  +  + ]:       4608 :                     Py_XDECREF(o);
    1012                 :            :                 }
    1013                 :            :                 assert(STACK_LEVEL() == 0);
    1014                 :       3459 :                 _PyFrame_SetStackPointer(frame, stack_pointer);
    1015         [ -  + ]:       3459 :                 TRACE_FUNCTION_UNWIND();
    1016         [ -  + ]:       3459 :                 DTRACE_FUNCTION_EXIT();
    1017                 :       3459 :                 goto exit_unwind;
    1018                 :            :             }
    1019                 :            : 
    1020                 :            :             assert(STACK_LEVEL() >= level);
    1021                 :     104227 :             PyObject **new_top = _PyFrame_Stackbase(frame) + level;
    1022         [ +  + ]:     110063 :             while (stack_pointer > new_top) {
    1023                 :       5836 :                 PyObject *v = POP();
    1024   [ +  +  +  + ]:       5836 :                 Py_XDECREF(v);
    1025                 :            :             }
    1026         [ +  + ]:     104227 :             if (lasti) {
    1027                 :       2548 :                 int frame_lasti = _PyInterpreterFrame_LASTI(frame);
    1028                 :       2548 :                 PyObject *lasti = PyLong_FromLong(frame_lasti);
    1029         [ -  + ]:       2548 :                 if (lasti == NULL) {
    1030                 :          0 :                     goto exception_unwind;
    1031                 :            :                 }
    1032                 :       2548 :                 PUSH(lasti);
    1033                 :            :             }
    1034                 :            : 
    1035                 :            :             /* Make the raw exception data
    1036                 :            :                 available to the handler,
    1037                 :            :                 so a program can emulate the
    1038                 :            :                 Python main loop. */
    1039                 :     104227 :             PUSH(_PyErr_GetRaisedException(tstate));
    1040                 :     104227 :             JUMPTO(handler);
    1041                 :            :             /* Resume normal execution */
    1042                 :     104227 :             DISPATCH();
    1043                 :            :         }
    1044                 :            :     }
    1045                 :            : 
    1046                 :       3459 : exit_unwind:
    1047                 :            :     assert(_PyErr_Occurred(tstate));
    1048                 :       3459 :     _Py_LeaveRecursiveCallPy(tstate);
    1049                 :            :     assert(frame != &entry_frame);
    1050                 :            :     // GH-99729: We need to unlink the frame *before* clearing it:
    1051                 :       3459 :     _PyInterpreterFrame *dying = frame;
    1052                 :       3459 :     frame = cframe.current_frame = dying->previous;
    1053                 :       3459 :     _PyEvalFrameClearAndPop(tstate, dying);
    1054         [ +  + ]:       3459 :     if (frame == &entry_frame) {
    1055                 :            :         /* Restore previous cframe and exit */
    1056                 :       2754 :         tstate->cframe = cframe.previous;
    1057                 :       2754 :         tstate->cframe->use_tracing = cframe.use_tracing;
    1058                 :            :         assert(tstate->cframe->current_frame == frame->previous);
    1059                 :       2754 :         _Py_LeaveRecursiveCallTstate(tstate);
    1060                 :       2754 :         return NULL;
    1061                 :            :     }
    1062                 :            : 
    1063                 :        705 : resume_with_error:
    1064                 :       2642 :     SET_LOCALS_FROM_FRAME();
    1065                 :       2642 :     goto error;
    1066                 :            : 
    1067                 :            : }
    1068                 :            : #if defined(__GNUC__)
    1069                 :            : #  pragma GCC diagnostic pop
    1070                 :            : #elif defined(_MSC_VER) /* MS_WINDOWS */
    1071                 :            : #  pragma warning(pop)
    1072                 :            : #endif
    1073                 :            : 
    1074                 :            : static void
    1075                 :          0 : format_missing(PyThreadState *tstate, const char *kind,
    1076                 :            :                PyCodeObject *co, PyObject *names, PyObject *qualname)
    1077                 :            : {
    1078                 :            :     int err;
    1079                 :          0 :     Py_ssize_t len = PyList_GET_SIZE(names);
    1080                 :            :     PyObject *name_str, *comma, *tail, *tmp;
    1081                 :            : 
    1082                 :            :     assert(PyList_CheckExact(names));
    1083                 :            :     assert(len >= 1);
    1084                 :            :     /* Deal with the joys of natural language. */
    1085      [ #  #  # ]:          0 :     switch (len) {
    1086                 :          0 :     case 1:
    1087                 :          0 :         name_str = PyList_GET_ITEM(names, 0);
    1088                 :          0 :         Py_INCREF(name_str);
    1089                 :          0 :         break;
    1090                 :          0 :     case 2:
    1091                 :          0 :         name_str = PyUnicode_FromFormat("%U and %U",
    1092                 :          0 :                                         PyList_GET_ITEM(names, len - 2),
    1093                 :          0 :                                         PyList_GET_ITEM(names, len - 1));
    1094                 :          0 :         break;
    1095                 :          0 :     default:
    1096                 :          0 :         tail = PyUnicode_FromFormat(", %U, and %U",
    1097                 :          0 :                                     PyList_GET_ITEM(names, len - 2),
    1098                 :          0 :                                     PyList_GET_ITEM(names, len - 1));
    1099         [ #  # ]:          0 :         if (tail == NULL)
    1100                 :          0 :             return;
    1101                 :            :         /* Chop off the last two objects in the list. This shouldn't actually
    1102                 :            :            fail, but we can't be too careful. */
    1103                 :          0 :         err = PyList_SetSlice(names, len - 2, len, NULL);
    1104         [ #  # ]:          0 :         if (err == -1) {
    1105         [ #  # ]:          0 :             Py_DECREF(tail);
    1106                 :          0 :             return;
    1107                 :            :         }
    1108                 :            :         /* Stitch everything up into a nice comma-separated list. */
    1109                 :          0 :         comma = PyUnicode_FromString(", ");
    1110         [ #  # ]:          0 :         if (comma == NULL) {
    1111         [ #  # ]:          0 :             Py_DECREF(tail);
    1112                 :          0 :             return;
    1113                 :            :         }
    1114                 :          0 :         tmp = PyUnicode_Join(comma, names);
    1115         [ #  # ]:          0 :         Py_DECREF(comma);
    1116         [ #  # ]:          0 :         if (tmp == NULL) {
    1117         [ #  # ]:          0 :             Py_DECREF(tail);
    1118                 :          0 :             return;
    1119                 :            :         }
    1120                 :          0 :         name_str = PyUnicode_Concat(tmp, tail);
    1121         [ #  # ]:          0 :         Py_DECREF(tmp);
    1122         [ #  # ]:          0 :         Py_DECREF(tail);
    1123                 :          0 :         break;
    1124                 :            :     }
    1125         [ #  # ]:          0 :     if (name_str == NULL)
    1126                 :          0 :         return;
    1127         [ #  # ]:          0 :     _PyErr_Format(tstate, PyExc_TypeError,
    1128                 :            :                   "%U() missing %i required %s argument%s: %U",
    1129                 :            :                   qualname,
    1130                 :            :                   len,
    1131                 :            :                   kind,
    1132                 :            :                   len == 1 ? "" : "s",
    1133                 :            :                   name_str);
    1134         [ #  # ]:          0 :     Py_DECREF(name_str);
    1135                 :            : }
    1136                 :            : 
    1137                 :            : static void
    1138                 :          0 : missing_arguments(PyThreadState *tstate, PyCodeObject *co,
    1139                 :            :                   Py_ssize_t missing, Py_ssize_t defcount,
    1140                 :            :                   PyObject **localsplus, PyObject *qualname)
    1141                 :            : {
    1142                 :          0 :     Py_ssize_t i, j = 0;
    1143                 :            :     Py_ssize_t start, end;
    1144                 :          0 :     int positional = (defcount != -1);
    1145         [ #  # ]:          0 :     const char *kind = positional ? "positional" : "keyword-only";
    1146                 :            :     PyObject *missing_names;
    1147                 :            : 
    1148                 :            :     /* Compute the names of the arguments that are missing. */
    1149                 :          0 :     missing_names = PyList_New(missing);
    1150         [ #  # ]:          0 :     if (missing_names == NULL)
    1151                 :          0 :         return;
    1152         [ #  # ]:          0 :     if (positional) {
    1153                 :          0 :         start = 0;
    1154                 :          0 :         end = co->co_argcount - defcount;
    1155                 :            :     }
    1156                 :            :     else {
    1157                 :          0 :         start = co->co_argcount;
    1158                 :          0 :         end = start + co->co_kwonlyargcount;
    1159                 :            :     }
    1160         [ #  # ]:          0 :     for (i = start; i < end; i++) {
    1161         [ #  # ]:          0 :         if (localsplus[i] == NULL) {
    1162                 :          0 :             PyObject *raw = PyTuple_GET_ITEM(co->co_localsplusnames, i);
    1163                 :          0 :             PyObject *name = PyObject_Repr(raw);
    1164         [ #  # ]:          0 :             if (name == NULL) {
    1165         [ #  # ]:          0 :                 Py_DECREF(missing_names);
    1166                 :          0 :                 return;
    1167                 :            :             }
    1168                 :          0 :             PyList_SET_ITEM(missing_names, j++, name);
    1169                 :            :         }
    1170                 :            :     }
    1171                 :            :     assert(j == missing);
    1172                 :          0 :     format_missing(tstate, kind, co, missing_names, qualname);
    1173         [ #  # ]:          0 :     Py_DECREF(missing_names);
    1174                 :            : }
    1175                 :            : 
    1176                 :            : static void
    1177                 :          0 : too_many_positional(PyThreadState *tstate, PyCodeObject *co,
    1178                 :            :                     Py_ssize_t given, PyObject *defaults,
    1179                 :            :                     PyObject **localsplus, PyObject *qualname)
    1180                 :            : {
    1181                 :            :     int plural;
    1182                 :          0 :     Py_ssize_t kwonly_given = 0;
    1183                 :            :     Py_ssize_t i;
    1184                 :            :     PyObject *sig, *kwonly_sig;
    1185                 :          0 :     Py_ssize_t co_argcount = co->co_argcount;
    1186                 :            : 
    1187                 :            :     assert((co->co_flags & CO_VARARGS) == 0);
    1188                 :            :     /* Count missing keyword-only args. */
    1189         [ #  # ]:          0 :     for (i = co_argcount; i < co_argcount + co->co_kwonlyargcount; i++) {
    1190         [ #  # ]:          0 :         if (localsplus[i] != NULL) {
    1191                 :          0 :             kwonly_given++;
    1192                 :            :         }
    1193                 :            :     }
    1194         [ #  # ]:          0 :     Py_ssize_t defcount = defaults == NULL ? 0 : PyTuple_GET_SIZE(defaults);
    1195         [ #  # ]:          0 :     if (defcount) {
    1196                 :          0 :         Py_ssize_t atleast = co_argcount - defcount;
    1197                 :          0 :         plural = 1;
    1198                 :          0 :         sig = PyUnicode_FromFormat("from %zd to %zd", atleast, co_argcount);
    1199                 :            :     }
    1200                 :            :     else {
    1201                 :          0 :         plural = (co_argcount != 1);
    1202                 :          0 :         sig = PyUnicode_FromFormat("%zd", co_argcount);
    1203                 :            :     }
    1204         [ #  # ]:          0 :     if (sig == NULL)
    1205                 :          0 :         return;
    1206         [ #  # ]:          0 :     if (kwonly_given) {
    1207                 :          0 :         const char *format = " positional argument%s (and %zd keyword-only argument%s)";
    1208   [ #  #  #  # ]:          0 :         kwonly_sig = PyUnicode_FromFormat(format,
    1209                 :            :                                           given != 1 ? "s" : "",
    1210                 :            :                                           kwonly_given,
    1211                 :            :                                           kwonly_given != 1 ? "s" : "");
    1212         [ #  # ]:          0 :         if (kwonly_sig == NULL) {
    1213         [ #  # ]:          0 :             Py_DECREF(sig);
    1214                 :          0 :             return;
    1215                 :            :         }
    1216                 :            :     }
    1217                 :            :     else {
    1218                 :            :         /* This will not fail. */
    1219                 :          0 :         kwonly_sig = PyUnicode_FromString("");
    1220                 :            :         assert(kwonly_sig != NULL);
    1221                 :            :     }
    1222   [ #  #  #  # ]:          0 :     _PyErr_Format(tstate, PyExc_TypeError,
    1223                 :            :                   "%U() takes %U positional argument%s but %zd%U %s given",
    1224                 :            :                   qualname,
    1225                 :            :                   sig,
    1226                 :            :                   plural ? "s" : "",
    1227                 :            :                   given,
    1228                 :            :                   kwonly_sig,
    1229         [ #  # ]:          0 :                   given == 1 && !kwonly_given ? "was" : "were");
    1230         [ #  # ]:          0 :     Py_DECREF(sig);
    1231         [ #  # ]:          0 :     Py_DECREF(kwonly_sig);
    1232                 :            : }
    1233                 :            : 
    1234                 :            : static int
    1235                 :          0 : positional_only_passed_as_keyword(PyThreadState *tstate, PyCodeObject *co,
    1236                 :            :                                   Py_ssize_t kwcount, PyObject* kwnames,
    1237                 :            :                                   PyObject *qualname)
    1238                 :            : {
    1239                 :          0 :     int posonly_conflicts = 0;
    1240                 :          0 :     PyObject* posonly_names = PyList_New(0);
    1241         [ #  # ]:          0 :     if (posonly_names == NULL) {
    1242                 :          0 :         goto fail;
    1243                 :            :     }
    1244         [ #  # ]:          0 :     for(int k=0; k < co->co_posonlyargcount; k++){
    1245                 :          0 :         PyObject* posonly_name = PyTuple_GET_ITEM(co->co_localsplusnames, k);
    1246                 :            : 
    1247         [ #  # ]:          0 :         for (int k2=0; k2<kwcount; k2++){
    1248                 :            :             /* Compare the pointers first and fallback to PyObject_RichCompareBool*/
    1249                 :          0 :             PyObject* kwname = PyTuple_GET_ITEM(kwnames, k2);
    1250         [ #  # ]:          0 :             if (kwname == posonly_name){
    1251         [ #  # ]:          0 :                 if(PyList_Append(posonly_names, kwname) != 0) {
    1252                 :          0 :                     goto fail;
    1253                 :            :                 }
    1254                 :          0 :                 posonly_conflicts++;
    1255                 :          0 :                 continue;
    1256                 :            :             }
    1257                 :            : 
    1258                 :          0 :             int cmp = PyObject_RichCompareBool(posonly_name, kwname, Py_EQ);
    1259                 :            : 
    1260         [ #  # ]:          0 :             if ( cmp > 0) {
    1261         [ #  # ]:          0 :                 if(PyList_Append(posonly_names, kwname) != 0) {
    1262                 :          0 :                     goto fail;
    1263                 :            :                 }
    1264                 :          0 :                 posonly_conflicts++;
    1265         [ #  # ]:          0 :             } else if (cmp < 0) {
    1266                 :          0 :                 goto fail;
    1267                 :            :             }
    1268                 :            : 
    1269                 :            :         }
    1270                 :            :     }
    1271         [ #  # ]:          0 :     if (posonly_conflicts) {
    1272                 :          0 :         PyObject* comma = PyUnicode_FromString(", ");
    1273         [ #  # ]:          0 :         if (comma == NULL) {
    1274                 :          0 :             goto fail;
    1275                 :            :         }
    1276                 :          0 :         PyObject* error_names = PyUnicode_Join(comma, posonly_names);
    1277         [ #  # ]:          0 :         Py_DECREF(comma);
    1278         [ #  # ]:          0 :         if (error_names == NULL) {
    1279                 :          0 :             goto fail;
    1280                 :            :         }
    1281                 :          0 :         _PyErr_Format(tstate, PyExc_TypeError,
    1282                 :            :                       "%U() got some positional-only arguments passed"
    1283                 :            :                       " as keyword arguments: '%U'",
    1284                 :            :                       qualname, error_names);
    1285         [ #  # ]:          0 :         Py_DECREF(error_names);
    1286                 :          0 :         goto fail;
    1287                 :            :     }
    1288                 :            : 
    1289         [ #  # ]:          0 :     Py_DECREF(posonly_names);
    1290                 :          0 :     return 0;
    1291                 :            : 
    1292                 :          0 : fail:
    1293   [ #  #  #  # ]:          0 :     Py_XDECREF(posonly_names);
    1294                 :          0 :     return 1;
    1295                 :            : 
    1296                 :            : }
    1297                 :            : 
    1298                 :            : 
    1299                 :            : static inline unsigned char *
    1300                 :     101742 : scan_back_to_entry_start(unsigned char *p) {
    1301         [ +  + ]:     208985 :     for (; (p[0]&128) == 0; p--);
    1302                 :     101742 :     return p;
    1303                 :            : }
    1304                 :            : 
    1305                 :            : static inline unsigned char *
    1306                 :       6242 : skip_to_next_entry(unsigned char *p, unsigned char *end) {
    1307   [ +  +  +  + ]:      22682 :     while (p < end && ((p[0] & 128) == 0)) {
    1308                 :      16440 :         p++;
    1309                 :            :     }
    1310                 :       6242 :     return p;
    1311                 :            : }
    1312                 :            : 
    1313                 :            : 
    1314                 :            : #define MAX_LINEAR_SEARCH 40
    1315                 :            : 
    1316                 :            : static int
    1317                 :     107686 : get_exception_handler(PyCodeObject *code, int index, int *level, int *handler, int *lasti)
    1318                 :            : {
    1319                 :     107686 :     unsigned char *start = (unsigned char *)PyBytes_AS_STRING(code->co_exceptiontable);
    1320                 :     107686 :     unsigned char *end = start + PyBytes_GET_SIZE(code->co_exceptiontable);
    1321                 :            :     /* Invariants:
    1322                 :            :      * start_table == end_table OR
    1323                 :            :      * start_table points to a legal entry and end_table points
    1324                 :            :      * beyond the table or to a legal entry that is after index.
    1325                 :            :      */
    1326         [ +  + ]:     107686 :     if (end - start > MAX_LINEAR_SEARCH) {
    1327                 :            :         int offset;
    1328                 :     100533 :         parse_varint(start, &offset);
    1329         [ -  + ]:     100533 :         if (offset > index) {
    1330                 :          0 :             return 0;
    1331                 :            :         }
    1332                 :            :         do {
    1333                 :     101742 :             unsigned char * mid = start + ((end-start)>>1);
    1334                 :     101742 :             mid = scan_back_to_entry_start(mid);
    1335                 :     101742 :             parse_varint(mid, &offset);
    1336         [ +  + ]:     101742 :             if (offset > index) {
    1337                 :     100854 :                 end = mid;
    1338                 :            :             }
    1339                 :            :             else {
    1340                 :        888 :                 start = mid;
    1341                 :            :             }
    1342                 :            : 
    1343         [ +  + ]:     101742 :         } while (end - start > MAX_LINEAR_SEARCH);
    1344                 :            :     }
    1345                 :     107686 :     unsigned char *scan = start;
    1346         [ +  + ]:     113928 :     while (scan < end) {
    1347                 :            :         int start_offset, size;
    1348                 :     110809 :         scan = parse_varint(scan, &start_offset);
    1349         [ +  + ]:     110809 :         if (start_offset > index) {
    1350                 :        340 :             break;
    1351                 :            :         }
    1352                 :     110469 :         scan = parse_varint(scan, &size);
    1353         [ +  + ]:     110469 :         if (start_offset + size > index) {
    1354                 :     104227 :             scan = parse_varint(scan, handler);
    1355                 :            :             int depth_and_lasti;
    1356                 :     104227 :             parse_varint(scan, &depth_and_lasti);
    1357                 :     104227 :             *level = depth_and_lasti >> 1;
    1358                 :     104227 :             *lasti = depth_and_lasti & 1;
    1359                 :     104227 :             return 1;
    1360                 :            :         }
    1361                 :       6242 :         scan = skip_to_next_entry(scan, end);
    1362                 :            :     }
    1363                 :       3459 :     return 0;
    1364                 :            : }
    1365                 :            : 
    1366                 :            : static int
    1367                 :    1424205 : initialize_locals(PyThreadState *tstate, PyFunctionObject *func,
    1368                 :            :     PyObject **localsplus, PyObject *const *args,
    1369                 :            :     Py_ssize_t argcount, PyObject *kwnames)
    1370                 :            : {
    1371                 :    1424205 :     PyCodeObject *co = (PyCodeObject*)func->func_code;
    1372                 :    1424205 :     const Py_ssize_t total_args = co->co_argcount + co->co_kwonlyargcount;
    1373                 :            : 
    1374                 :            :     /* Create a dictionary for keyword parameters (**kwags) */
    1375                 :            :     PyObject *kwdict;
    1376                 :            :     Py_ssize_t i;
    1377         [ +  + ]:    1424205 :     if (co->co_flags & CO_VARKEYWORDS) {
    1378                 :     120689 :         kwdict = PyDict_New();
    1379         [ -  + ]:     120689 :         if (kwdict == NULL) {
    1380                 :          0 :             goto fail_pre_positional;
    1381                 :            :         }
    1382                 :     120689 :         i = total_args;
    1383         [ +  + ]:     120689 :         if (co->co_flags & CO_VARARGS) {
    1384                 :     104426 :             i++;
    1385                 :            :         }
    1386                 :            :         assert(localsplus[i] == NULL);
    1387                 :     120689 :         localsplus[i] = kwdict;
    1388                 :            :     }
    1389                 :            :     else {
    1390                 :    1303516 :         kwdict = NULL;
    1391                 :            :     }
    1392                 :            : 
    1393                 :            :     /* Copy all positional arguments into local variables */
    1394                 :            :     Py_ssize_t j, n;
    1395         [ +  + ]:    1424205 :     if (argcount > co->co_argcount) {
    1396                 :     131204 :         n = co->co_argcount;
    1397                 :            :     }
    1398                 :            :     else {
    1399                 :    1293001 :         n = argcount;
    1400                 :            :     }
    1401         [ +  + ]:    3993006 :     for (j = 0; j < n; j++) {
    1402                 :    2568801 :         PyObject *x = args[j];
    1403                 :            :         assert(localsplus[j] == NULL);
    1404                 :    2568801 :         localsplus[j] = x;
    1405                 :            :     }
    1406                 :            : 
    1407                 :            :     /* Pack other positional arguments into the *args argument */
    1408         [ +  + ]:    1424205 :     if (co->co_flags & CO_VARARGS) {
    1409                 :     132278 :         PyObject *u = NULL;
    1410         [ +  + ]:     132278 :         if (argcount == n) {
    1411                 :       1074 :             u = Py_NewRef(&_Py_SINGLETON(tuple_empty));
    1412                 :            :         }
    1413                 :            :         else {
    1414                 :            :             assert(args != NULL);
    1415                 :     131204 :             u = _PyTuple_FromArraySteal(args + n, argcount - n);
    1416                 :            :         }
    1417         [ -  + ]:     132278 :         if (u == NULL) {
    1418                 :          0 :             goto fail_post_positional;
    1419                 :            :         }
    1420                 :            :         assert(localsplus[total_args] == NULL);
    1421                 :     132278 :         localsplus[total_args] = u;
    1422                 :            :     }
    1423         [ -  + ]:    1291927 :     else if (argcount > n) {
    1424                 :            :         /* Too many postional args. Error is reported later */
    1425         [ #  # ]:          0 :         for (j = n; j < argcount; j++) {
    1426         [ #  # ]:          0 :             Py_DECREF(args[j]);
    1427                 :            :         }
    1428                 :            :     }
    1429                 :            : 
    1430                 :            :     /* Handle keyword arguments */
    1431         [ +  + ]:    1424205 :     if (kwnames != NULL) {
    1432                 :     202192 :         Py_ssize_t kwcount = PyTuple_GET_SIZE(kwnames);
    1433         [ +  + ]:     408526 :         for (i = 0; i < kwcount; i++) {
    1434                 :            :             PyObject **co_varnames;
    1435                 :     206334 :             PyObject *keyword = PyTuple_GET_ITEM(kwnames, i);
    1436                 :     206334 :             PyObject *value = args[i+argcount];
    1437                 :            :             Py_ssize_t j;
    1438                 :            : 
    1439   [ +  -  -  + ]:     206334 :             if (keyword == NULL || !PyUnicode_Check(keyword)) {
    1440                 :          0 :                 _PyErr_Format(tstate, PyExc_TypeError,
    1441                 :            :                             "%U() keywords must be strings",
    1442                 :            :                           func->func_qualname);
    1443                 :          0 :                 goto kw_fail;
    1444                 :            :             }
    1445                 :            : 
    1446                 :            :             /* Speed hack: do raw pointer compares. As names are
    1447                 :            :             normally interned this should almost always hit. */
    1448                 :     206334 :             co_varnames = ((PyTupleObject *)(co->co_localsplusnames))->ob_item;
    1449         [ +  + ]:     701540 :             for (j = co->co_posonlyargcount; j < total_args; j++) {
    1450                 :     657661 :                 PyObject *varname = co_varnames[j];
    1451         [ +  + ]:     657661 :                 if (varname == keyword) {
    1452                 :     162455 :                     goto kw_found;
    1453                 :            :                 }
    1454                 :            :             }
    1455                 :            : 
    1456                 :            :             /* Slow fallback, just in case */
    1457         [ +  + ]:      73558 :             for (j = co->co_posonlyargcount; j < total_args; j++) {
    1458                 :      29679 :                 PyObject *varname = co_varnames[j];
    1459                 :      29679 :                 int cmp = PyObject_RichCompareBool( keyword, varname, Py_EQ);
    1460         [ -  + ]:      29679 :                 if (cmp > 0) {
    1461                 :          0 :                     goto kw_found;
    1462                 :            :                 }
    1463         [ -  + ]:      29679 :                 else if (cmp < 0) {
    1464                 :          0 :                     goto kw_fail;
    1465                 :            :                 }
    1466                 :            :             }
    1467                 :            : 
    1468                 :            :             assert(j >= total_args);
    1469         [ -  + ]:      43879 :             if (kwdict == NULL) {
    1470                 :            : 
    1471         [ #  # ]:          0 :                 if (co->co_posonlyargcount
    1472         [ #  # ]:          0 :                     && positional_only_passed_as_keyword(tstate, co,
    1473                 :            :                                                         kwcount, kwnames,
    1474                 :            :                                                         func->func_qualname))
    1475                 :            :                 {
    1476                 :          0 :                     goto kw_fail;
    1477                 :            :                 }
    1478                 :            : 
    1479                 :          0 :                 _PyErr_Format(tstate, PyExc_TypeError,
    1480                 :            :                             "%U() got an unexpected keyword argument '%S'",
    1481                 :            :                           func->func_qualname, keyword);
    1482                 :          0 :                 goto kw_fail;
    1483                 :            :             }
    1484                 :            : 
    1485         [ -  + ]:      43879 :             if (PyDict_SetItem(kwdict, keyword, value) == -1) {
    1486                 :          0 :                 goto kw_fail;
    1487                 :            :             }
    1488         [ -  + ]:      43879 :             Py_DECREF(value);
    1489                 :      43879 :             continue;
    1490                 :            : 
    1491                 :          0 :         kw_fail:
    1492         [ #  # ]:          0 :             for (;i < kwcount; i++) {
    1493                 :          0 :                 PyObject *value = args[i+argcount];
    1494         [ #  # ]:          0 :                 Py_DECREF(value);
    1495                 :            :             }
    1496                 :          0 :             goto fail_post_args;
    1497                 :            : 
    1498                 :     162455 :         kw_found:
    1499         [ -  + ]:     162455 :             if (localsplus[j] != NULL) {
    1500                 :          0 :                 _PyErr_Format(tstate, PyExc_TypeError,
    1501                 :            :                             "%U() got multiple values for argument '%S'",
    1502                 :            :                           func->func_qualname, keyword);
    1503                 :          0 :                 goto kw_fail;
    1504                 :            :             }
    1505                 :     162455 :             localsplus[j] = value;
    1506                 :            :         }
    1507                 :            :     }
    1508                 :            : 
    1509                 :            :     /* Check the number of positional arguments */
    1510   [ +  +  -  + ]:    1424205 :     if ((argcount > co->co_argcount) && !(co->co_flags & CO_VARARGS)) {
    1511                 :          0 :         too_many_positional(tstate, co, argcount, func->func_defaults, localsplus,
    1512                 :            :                             func->func_qualname);
    1513                 :          0 :         goto fail_post_args;
    1514                 :            :     }
    1515                 :            : 
    1516                 :            :     /* Add missing positional arguments (copy default values from defs) */
    1517         [ +  + ]:    1424205 :     if (argcount < co->co_argcount) {
    1518         [ +  + ]:     252898 :         Py_ssize_t defcount = func->func_defaults == NULL ? 0 : PyTuple_GET_SIZE(func->func_defaults);
    1519                 :     252898 :         Py_ssize_t m = co->co_argcount - defcount;
    1520                 :     252898 :         Py_ssize_t missing = 0;
    1521         [ +  + ]:     253417 :         for (i = argcount; i < m; i++) {
    1522         [ -  + ]:        519 :             if (localsplus[i] == NULL) {
    1523                 :          0 :                 missing++;
    1524                 :            :             }
    1525                 :            :         }
    1526         [ -  + ]:     252898 :         if (missing) {
    1527                 :          0 :             missing_arguments(tstate, co, missing, defcount, localsplus,
    1528                 :            :                               func->func_qualname);
    1529                 :          0 :             goto fail_post_args;
    1530                 :            :         }
    1531         [ +  + ]:     252898 :         if (n > m)
    1532                 :      50671 :             i = n - m;
    1533                 :            :         else
    1534                 :     202227 :             i = 0;
    1535         [ +  + ]:     252898 :         if (defcount) {
    1536                 :     252854 :             PyObject **defs = &PyTuple_GET_ITEM(func->func_defaults, 0);
    1537         [ +  + ]:     509718 :             for (; i < defcount; i++) {
    1538         [ +  + ]:     256864 :                 if (localsplus[m+i] == NULL) {
    1539                 :     103036 :                     PyObject *def = defs[i];
    1540                 :     103036 :                     localsplus[m+i] = Py_NewRef(def);
    1541                 :            :                 }
    1542                 :            :             }
    1543                 :            :         }
    1544                 :            :     }
    1545                 :            : 
    1546                 :            :     /* Add missing keyword arguments (copy default values from kwdefs) */
    1547         [ +  + ]:    1424205 :     if (co->co_kwonlyargcount > 0) {
    1548                 :      12416 :         Py_ssize_t missing = 0;
    1549         [ +  + ]:      30564 :         for (i = co->co_argcount; i < total_args; i++) {
    1550         [ +  + ]:      18148 :             if (localsplus[i] != NULL)
    1551                 :       8108 :                 continue;
    1552                 :      10040 :             PyObject *varname = PyTuple_GET_ITEM(co->co_localsplusnames, i);
    1553         [ +  - ]:      10040 :             if (func->func_kwdefaults != NULL) {
    1554                 :      10040 :                 PyObject *def = PyDict_GetItemWithError(func->func_kwdefaults, varname);
    1555         [ +  - ]:      10040 :                 if (def) {
    1556                 :      10040 :                     localsplus[i] = Py_NewRef(def);
    1557                 :      10040 :                     continue;
    1558                 :            :                 }
    1559         [ #  # ]:          0 :                 else if (_PyErr_Occurred(tstate)) {
    1560                 :          0 :                     goto fail_post_args;
    1561                 :            :                 }
    1562                 :            :             }
    1563                 :          0 :             missing++;
    1564                 :            :         }
    1565         [ -  + ]:      12416 :         if (missing) {
    1566                 :          0 :             missing_arguments(tstate, co, missing, -1, localsplus,
    1567                 :            :                               func->func_qualname);
    1568                 :          0 :             goto fail_post_args;
    1569                 :            :         }
    1570                 :            :     }
    1571                 :    1424205 :     return 0;
    1572                 :            : 
    1573                 :          0 : fail_pre_positional:
    1574         [ #  # ]:          0 :     for (j = 0; j < argcount; j++) {
    1575         [ #  # ]:          0 :         Py_DECREF(args[j]);
    1576                 :            :     }
    1577                 :            :     /* fall through */
    1578                 :          0 : fail_post_positional:
    1579         [ #  # ]:          0 :     if (kwnames) {
    1580                 :          0 :         Py_ssize_t kwcount = PyTuple_GET_SIZE(kwnames);
    1581         [ #  # ]:          0 :         for (j = argcount; j < argcount+kwcount; j++) {
    1582         [ #  # ]:          0 :             Py_DECREF(args[j]);
    1583                 :            :         }
    1584                 :            :     }
    1585                 :            :     /* fall through */
    1586                 :          0 : fail_post_args:
    1587                 :          0 :     return -1;
    1588                 :            : }
    1589                 :            : 
    1590                 :            : static void
    1591                 :    3485728 : clear_thread_frame(PyThreadState *tstate, _PyInterpreterFrame * frame)
    1592                 :            : {
    1593                 :            :     assert(frame->owner == FRAME_OWNED_BY_THREAD);
    1594                 :            :     // Make sure that this is, indeed, the top frame. We can't check this in
    1595                 :            :     // _PyThreadState_PopFrame, since f_code is already cleared at that point:
    1596                 :            :     assert((PyObject **)frame + frame->f_code->co_framesize ==
    1597                 :            :         tstate->datastack_top);
    1598                 :    3485728 :     tstate->c_recursion_remaining--;
    1599                 :            :     assert(frame->frame_obj == NULL || frame->frame_obj->f_frame == frame);
    1600                 :    3485728 :     _PyFrame_ClearExceptCode(frame);
    1601         [ -  + ]:    3485728 :     Py_DECREF(frame->f_code);
    1602                 :    3485728 :     tstate->c_recursion_remaining++;
    1603                 :    3485728 :     _PyThreadState_PopFrame(tstate, frame);
    1604                 :    3485728 : }
    1605                 :            : 
    1606                 :            : static void
    1607                 :     122330 : clear_gen_frame(PyThreadState *tstate, _PyInterpreterFrame * frame)
    1608                 :            : {
    1609                 :            :     assert(frame->owner == FRAME_OWNED_BY_GENERATOR);
    1610                 :     122330 :     PyGenObject *gen = _PyFrame_GetGenerator(frame);
    1611                 :     122330 :     gen->gi_frame_state = FRAME_CLEARED;
    1612                 :            :     assert(tstate->exc_info == &gen->gi_exc_state);
    1613                 :     122330 :     tstate->exc_info = gen->gi_exc_state.previous_item;
    1614                 :     122330 :     gen->gi_exc_state.previous_item = NULL;
    1615                 :     122330 :     tstate->c_recursion_remaining--;
    1616                 :            :     assert(frame->frame_obj == NULL || frame->frame_obj->f_frame == frame);
    1617                 :     122330 :     _PyFrame_ClearExceptCode(frame);
    1618                 :     122330 :     tstate->c_recursion_remaining++;
    1619                 :     122330 :     frame->previous = NULL;
    1620                 :     122330 : }
    1621                 :            : 
    1622                 :            : static void
    1623                 :    3608058 : _PyEvalFrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame * frame)
    1624                 :            : {
    1625         [ +  + ]:    3608058 :     if (frame->owner == FRAME_OWNED_BY_THREAD) {
    1626                 :    3485728 :         clear_thread_frame(tstate, frame);
    1627                 :            :     }
    1628                 :            :     else {
    1629                 :     122330 :         clear_gen_frame(tstate, frame);
    1630                 :            :     }
    1631                 :    3608058 : }
    1632                 :            : 
    1633                 :            : /* Consumes references to func, locals and all the args */
    1634                 :            : static _PyInterpreterFrame *
    1635                 :    1424205 : _PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,
    1636                 :            :                         PyObject *locals, PyObject* const* args,
    1637                 :            :                         size_t argcount, PyObject *kwnames)
    1638                 :            : {
    1639                 :    1424205 :     PyCodeObject * code = (PyCodeObject *)func->func_code;
    1640                 :            :     CALL_STAT_INC(frames_pushed);
    1641                 :    1424205 :     _PyInterpreterFrame *frame = _PyThreadState_PushFrame(tstate, code->co_framesize);
    1642         [ -  + ]:    1424205 :     if (frame == NULL) {
    1643                 :          0 :         goto fail;
    1644                 :            :     }
    1645                 :    1424205 :     _PyFrame_Initialize(frame, func, locals, code, 0);
    1646         [ -  + ]:    1424205 :     if (initialize_locals(tstate, func, frame->localsplus, args, argcount, kwnames)) {
    1647                 :            :         assert(frame->owner == FRAME_OWNED_BY_THREAD);
    1648                 :          0 :         clear_thread_frame(tstate, frame);
    1649                 :          0 :         return NULL;
    1650                 :            :     }
    1651                 :    1424205 :     return frame;
    1652                 :          0 : fail:
    1653                 :            :     /* Consume the references */
    1654         [ #  # ]:          0 :     for (size_t i = 0; i < argcount; i++) {
    1655         [ #  # ]:          0 :         Py_DECREF(args[i]);
    1656                 :            :     }
    1657         [ #  # ]:          0 :     if (kwnames) {
    1658                 :          0 :         Py_ssize_t kwcount = PyTuple_GET_SIZE(kwnames);
    1659         [ #  # ]:          0 :         for (Py_ssize_t i = 0; i < kwcount; i++) {
    1660         [ #  # ]:          0 :             Py_DECREF(args[i+argcount]);
    1661                 :            :         }
    1662                 :            :     }
    1663                 :          0 :     PyErr_NoMemory();
    1664                 :          0 :     return NULL;
    1665                 :            : }
    1666                 :            : 
    1667                 :            : PyObject *
    1668                 :    1130299 : _PyEval_Vector(PyThreadState *tstate, PyFunctionObject *func,
    1669                 :            :                PyObject *locals,
    1670                 :            :                PyObject* const* args, size_t argcount,
    1671                 :            :                PyObject *kwnames)
    1672                 :            : {
    1673                 :            :     /* _PyEvalFramePushAndInit consumes the references
    1674                 :            :      * to func, locals and all its arguments */
    1675                 :    1130299 :     Py_INCREF(func);
    1676                 :    1130299 :     Py_XINCREF(locals);
    1677         [ +  + ]:    3230951 :     for (size_t i = 0; i < argcount; i++) {
    1678                 :    2100652 :         Py_INCREF(args[i]);
    1679                 :            :     }
    1680         [ +  + ]:    1130299 :     if (kwnames) {
    1681                 :      30413 :         Py_ssize_t kwcount = PyTuple_GET_SIZE(kwnames);
    1682         [ +  + ]:      62341 :         for (Py_ssize_t i = 0; i < kwcount; i++) {
    1683                 :      31928 :             Py_INCREF(args[i+argcount]);
    1684                 :            :         }
    1685                 :            :     }
    1686                 :    1130299 :     _PyInterpreterFrame *frame = _PyEvalFramePushAndInit(
    1687                 :            :         tstate, func, locals, args, argcount, kwnames);
    1688         [ -  + ]:    1130299 :     if (frame == NULL) {
    1689                 :          0 :         return NULL;
    1690                 :            :     }
    1691                 :            :     EVAL_CALL_STAT_INC(EVAL_CALL_VECTOR);
    1692                 :    1130299 :     return _PyEval_EvalFrame(tstate, frame, 0);
    1693                 :            : }
    1694                 :            : 
    1695                 :            : /* Legacy API */
    1696                 :            : PyObject *
    1697                 :          0 : PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
    1698                 :            :                   PyObject *const *args, int argcount,
    1699                 :            :                   PyObject *const *kws, int kwcount,
    1700                 :            :                   PyObject *const *defs, int defcount,
    1701                 :            :                   PyObject *kwdefs, PyObject *closure)
    1702                 :            : {
    1703                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    1704                 :          0 :     PyObject *res = NULL;
    1705                 :          0 :     PyObject *defaults = _PyTuple_FromArray(defs, defcount);
    1706         [ #  # ]:          0 :     if (defaults == NULL) {
    1707                 :          0 :         return NULL;
    1708                 :            :     }
    1709                 :          0 :     PyObject *builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref
    1710         [ #  # ]:          0 :     if (builtins == NULL) {
    1711         [ #  # ]:          0 :         Py_DECREF(defaults);
    1712                 :          0 :         return NULL;
    1713                 :            :     }
    1714         [ #  # ]:          0 :     if (locals == NULL) {
    1715                 :          0 :         locals = globals;
    1716                 :            :     }
    1717                 :          0 :     PyObject *kwnames = NULL;
    1718                 :            :     PyObject *const *allargs;
    1719                 :          0 :     PyObject **newargs = NULL;
    1720                 :          0 :     PyFunctionObject *func = NULL;
    1721         [ #  # ]:          0 :     if (kwcount == 0) {
    1722                 :          0 :         allargs = args;
    1723                 :            :     }
    1724                 :            :     else {
    1725                 :          0 :         kwnames = PyTuple_New(kwcount);
    1726         [ #  # ]:          0 :         if (kwnames == NULL) {
    1727                 :          0 :             goto fail;
    1728                 :            :         }
    1729                 :          0 :         newargs = PyMem_Malloc(sizeof(PyObject *)*(kwcount+argcount));
    1730         [ #  # ]:          0 :         if (newargs == NULL) {
    1731                 :          0 :             goto fail;
    1732                 :            :         }
    1733         [ #  # ]:          0 :         for (int i = 0; i < argcount; i++) {
    1734                 :          0 :             newargs[i] = args[i];
    1735                 :            :         }
    1736         [ #  # ]:          0 :         for (int i = 0; i < kwcount; i++) {
    1737                 :          0 :             PyTuple_SET_ITEM(kwnames, i, Py_NewRef(kws[2*i]));
    1738                 :          0 :             newargs[argcount+i] = kws[2*i+1];
    1739                 :            :         }
    1740                 :          0 :         allargs = newargs;
    1741                 :            :     }
    1742                 :          0 :     PyFrameConstructor constr = {
    1743                 :            :         .fc_globals = globals,
    1744                 :            :         .fc_builtins = builtins,
    1745                 :          0 :         .fc_name = ((PyCodeObject *)_co)->co_name,
    1746                 :          0 :         .fc_qualname = ((PyCodeObject *)_co)->co_name,
    1747                 :            :         .fc_code = _co,
    1748                 :            :         .fc_defaults = defaults,
    1749                 :            :         .fc_kwdefaults = kwdefs,
    1750                 :            :         .fc_closure = closure
    1751                 :            :     };
    1752                 :          0 :     func = _PyFunction_FromConstructor(&constr);
    1753         [ #  # ]:          0 :     if (func == NULL) {
    1754                 :          0 :         goto fail;
    1755                 :            :     }
    1756                 :            :     EVAL_CALL_STAT_INC(EVAL_CALL_LEGACY);
    1757                 :          0 :     res = _PyEval_Vector(tstate, func, locals,
    1758                 :            :                          allargs, argcount,
    1759                 :            :                          kwnames);
    1760                 :          0 : fail:
    1761   [ #  #  #  # ]:          0 :     Py_XDECREF(func);
    1762   [ #  #  #  # ]:          0 :     Py_XDECREF(kwnames);
    1763                 :          0 :     PyMem_Free(newargs);
    1764         [ #  # ]:          0 :     Py_DECREF(defaults);
    1765                 :          0 :     return res;
    1766                 :            : }
    1767                 :            : 
    1768                 :            : 
    1769                 :            : /* Logic for the raise statement (too complicated for inlining).
    1770                 :            :    This *consumes* a reference count to each of its arguments. */
    1771                 :            : static int
    1772                 :        413 : do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause)
    1773                 :            : {
    1774                 :        413 :     PyObject *type = NULL, *value = NULL;
    1775                 :            : 
    1776         [ +  + ]:        413 :     if (exc == NULL) {
    1777                 :            :         /* Reraise */
    1778                 :          2 :         _PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate);
    1779                 :          2 :         exc = exc_info->exc_value;
    1780   [ +  -  -  + ]:          2 :         if (Py_IsNone(exc) || exc == NULL) {
    1781                 :          0 :             _PyErr_SetString(tstate, PyExc_RuntimeError,
    1782                 :            :                              "No active exception to reraise");
    1783                 :          0 :             return 0;
    1784                 :            :         }
    1785                 :          2 :         Py_INCREF(exc);
    1786                 :            :         assert(PyExceptionInstance_Check(exc));
    1787                 :          2 :         _PyErr_SetRaisedException(tstate, exc);
    1788                 :          2 :         return 1;
    1789                 :            :     }
    1790                 :            : 
    1791                 :            :     /* We support the following forms of raise:
    1792                 :            :        raise
    1793                 :            :        raise <instance>
    1794                 :            :        raise <type> */
    1795                 :            : 
    1796   [ +  +  +  - ]:        411 :     if (PyExceptionClass_Check(exc)) {
    1797                 :         22 :         type = exc;
    1798                 :         22 :         value = _PyObject_CallNoArgs(exc);
    1799         [ -  + ]:         22 :         if (value == NULL)
    1800                 :          0 :             goto raise_error;
    1801         [ -  + ]:         22 :         if (!PyExceptionInstance_Check(value)) {
    1802                 :          0 :             _PyErr_Format(tstate, PyExc_TypeError,
    1803                 :            :                           "calling %R should have returned an instance of "
    1804                 :            :                           "BaseException, not %R",
    1805                 :            :                           type, Py_TYPE(value));
    1806                 :          0 :              goto raise_error;
    1807                 :            :         }
    1808                 :            :     }
    1809         [ +  - ]:        389 :     else if (PyExceptionInstance_Check(exc)) {
    1810                 :        389 :         value = exc;
    1811                 :        389 :         type = PyExceptionInstance_Class(exc);
    1812                 :        389 :         Py_INCREF(type);
    1813                 :            :     }
    1814                 :            :     else {
    1815                 :            :         /* Not something you can raise.  You get an exception
    1816                 :            :            anyway, just not what you specified :-) */
    1817         [ #  # ]:          0 :         Py_DECREF(exc);
    1818                 :          0 :         _PyErr_SetString(tstate, PyExc_TypeError,
    1819                 :            :                          "exceptions must derive from BaseException");
    1820                 :          0 :         goto raise_error;
    1821                 :            :     }
    1822                 :            : 
    1823                 :            :     assert(type != NULL);
    1824                 :            :     assert(value != NULL);
    1825                 :            : 
    1826         [ +  + ]:        411 :     if (cause) {
    1827                 :            :         PyObject *fixed_cause;
    1828   [ -  +  -  - ]:         93 :         if (PyExceptionClass_Check(cause)) {
    1829                 :          0 :             fixed_cause = _PyObject_CallNoArgs(cause);
    1830         [ #  # ]:          0 :             if (fixed_cause == NULL)
    1831                 :          0 :                 goto raise_error;
    1832         [ #  # ]:          0 :             Py_DECREF(cause);
    1833                 :            :         }
    1834         [ -  + ]:         93 :         else if (PyExceptionInstance_Check(cause)) {
    1835                 :          0 :             fixed_cause = cause;
    1836                 :            :         }
    1837         [ +  - ]:         93 :         else if (Py_IsNone(cause)) {
    1838         [ -  + ]:         93 :             Py_DECREF(cause);
    1839                 :         93 :             fixed_cause = NULL;
    1840                 :            :         }
    1841                 :            :         else {
    1842                 :          0 :             _PyErr_SetString(tstate, PyExc_TypeError,
    1843                 :            :                              "exception causes must derive from "
    1844                 :            :                              "BaseException");
    1845                 :          0 :             goto raise_error;
    1846                 :            :         }
    1847                 :         93 :         PyException_SetCause(value, fixed_cause);
    1848                 :            :     }
    1849                 :            : 
    1850                 :        411 :     _PyErr_SetObject(tstate, type, value);
    1851                 :            :     /* _PyErr_SetObject incref's its arguments */
    1852         [ -  + ]:        411 :     Py_DECREF(value);
    1853         [ -  + ]:        411 :     Py_DECREF(type);
    1854                 :        411 :     return 0;
    1855                 :            : 
    1856                 :          0 : raise_error:
    1857   [ #  #  #  # ]:          0 :     Py_XDECREF(value);
    1858   [ #  #  #  # ]:          0 :     Py_XDECREF(type);
    1859   [ #  #  #  # ]:          0 :     Py_XDECREF(cause);
    1860                 :          0 :     return 0;
    1861                 :            : }
    1862                 :            : 
    1863                 :            : /* Logic for matching an exception in an except* clause (too
    1864                 :            :    complicated for inlining).
    1865                 :            : */
    1866                 :            : 
    1867                 :            : static int
    1868                 :          0 : exception_group_match(PyObject* exc_value, PyObject *match_type,
    1869                 :            :                       PyObject **match, PyObject **rest)
    1870                 :            : {
    1871         [ #  # ]:          0 :     if (Py_IsNone(exc_value)) {
    1872                 :          0 :         *match = Py_NewRef(Py_None);
    1873                 :          0 :         *rest = Py_NewRef(Py_None);
    1874                 :          0 :         return 0;
    1875                 :            :     }
    1876                 :            :     assert(PyExceptionInstance_Check(exc_value));
    1877                 :            : 
    1878         [ #  # ]:          0 :     if (PyErr_GivenExceptionMatches(exc_value, match_type)) {
    1879                 :            :         /* Full match of exc itself */
    1880                 :          0 :         bool is_eg = _PyBaseExceptionGroup_Check(exc_value);
    1881         [ #  # ]:          0 :         if (is_eg) {
    1882                 :          0 :             *match = Py_NewRef(exc_value);
    1883                 :            :         }
    1884                 :            :         else {
    1885                 :            :             /* naked exception - wrap it */
    1886                 :          0 :             PyObject *excs = PyTuple_Pack(1, exc_value);
    1887         [ #  # ]:          0 :             if (excs == NULL) {
    1888                 :          0 :                 return -1;
    1889                 :            :             }
    1890                 :          0 :             PyObject *wrapped = _PyExc_CreateExceptionGroup("", excs);
    1891         [ #  # ]:          0 :             Py_DECREF(excs);
    1892         [ #  # ]:          0 :             if (wrapped == NULL) {
    1893                 :          0 :                 return -1;
    1894                 :            :             }
    1895                 :          0 :             *match = wrapped;
    1896                 :            :         }
    1897                 :          0 :         *rest = Py_NewRef(Py_None);
    1898                 :          0 :         return 0;
    1899                 :            :     }
    1900                 :            : 
    1901                 :            :     /* exc_value does not match match_type.
    1902                 :            :      * Check for partial match if it's an exception group.
    1903                 :            :      */
    1904         [ #  # ]:          0 :     if (_PyBaseExceptionGroup_Check(exc_value)) {
    1905                 :          0 :         PyObject *pair = PyObject_CallMethod(exc_value, "split", "(O)",
    1906                 :            :                                              match_type);
    1907         [ #  # ]:          0 :         if (pair == NULL) {
    1908                 :          0 :             return -1;
    1909                 :            :         }
    1910                 :            :         assert(PyTuple_CheckExact(pair));
    1911                 :            :         assert(PyTuple_GET_SIZE(pair) == 2);
    1912                 :          0 :         *match = Py_NewRef(PyTuple_GET_ITEM(pair, 0));
    1913                 :          0 :         *rest = Py_NewRef(PyTuple_GET_ITEM(pair, 1));
    1914         [ #  # ]:          0 :         Py_DECREF(pair);
    1915                 :          0 :         return 0;
    1916                 :            :     }
    1917                 :            :     /* no match */
    1918                 :          0 :     *match = Py_NewRef(Py_None);
    1919                 :          0 :     *rest = Py_NewRef(exc_value);
    1920                 :          0 :     return 0;
    1921                 :            : }
    1922                 :            : 
    1923                 :            : /* Iterate v argcnt times and store the results on the stack (via decreasing
    1924                 :            :    sp).  Return 1 for success, 0 if error.
    1925                 :            : 
    1926                 :            :    If argcntafter == -1, do a simple unpack. If it is >= 0, do an unpack
    1927                 :            :    with a variable target.
    1928                 :            : */
    1929                 :            : 
    1930                 :            : static int
    1931                 :       2665 : unpack_iterable(PyThreadState *tstate, PyObject *v,
    1932                 :            :                 int argcnt, int argcntafter, PyObject **sp)
    1933                 :            : {
    1934                 :       2665 :     int i = 0, j = 0;
    1935                 :       2665 :     Py_ssize_t ll = 0;
    1936                 :            :     PyObject *it;  /* iter(v) */
    1937                 :            :     PyObject *w;
    1938                 :       2665 :     PyObject *l = NULL; /* variable list */
    1939                 :            : 
    1940                 :            :     assert(v != NULL);
    1941                 :            : 
    1942                 :       2665 :     it = PyObject_GetIter(v);
    1943         [ -  + ]:       2665 :     if (it == NULL) {
    1944         [ #  # ]:          0 :         if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError) &&
    1945   [ #  #  #  # ]:          0 :             Py_TYPE(v)->tp_iter == NULL && !PySequence_Check(v))
    1946                 :            :         {
    1947                 :          0 :             _PyErr_Format(tstate, PyExc_TypeError,
    1948                 :            :                           "cannot unpack non-iterable %.200s object",
    1949                 :          0 :                           Py_TYPE(v)->tp_name);
    1950                 :            :         }
    1951                 :          0 :         return 0;
    1952                 :            :     }
    1953                 :            : 
    1954         [ +  + ]:       7807 :     for (; i < argcnt; i++) {
    1955                 :       5142 :         w = PyIter_Next(it);
    1956         [ -  + ]:       5142 :         if (w == NULL) {
    1957                 :            :             /* Iterator done, via error or exhaustion. */
    1958         [ #  # ]:          0 :             if (!_PyErr_Occurred(tstate)) {
    1959         [ #  # ]:          0 :                 if (argcntafter == -1) {
    1960                 :          0 :                     _PyErr_Format(tstate, PyExc_ValueError,
    1961                 :            :                                   "not enough values to unpack "
    1962                 :            :                                   "(expected %d, got %d)",
    1963                 :            :                                   argcnt, i);
    1964                 :            :                 }
    1965                 :            :                 else {
    1966                 :          0 :                     _PyErr_Format(tstate, PyExc_ValueError,
    1967                 :            :                                   "not enough values to unpack "
    1968                 :            :                                   "(expected at least %d, got %d)",
    1969                 :            :                                   argcnt + argcntafter, i);
    1970                 :            :                 }
    1971                 :            :             }
    1972                 :          0 :             goto Error;
    1973                 :            :         }
    1974                 :       5142 :         *--sp = w;
    1975                 :            :     }
    1976                 :            : 
    1977         [ +  + ]:       2665 :     if (argcntafter == -1) {
    1978                 :            :         /* We better have exhausted the iterator now. */
    1979                 :        671 :         w = PyIter_Next(it);
    1980         [ +  - ]:        671 :         if (w == NULL) {
    1981         [ -  + ]:        671 :             if (_PyErr_Occurred(tstate))
    1982                 :          0 :                 goto Error;
    1983         [ +  - ]:        671 :             Py_DECREF(it);
    1984                 :        671 :             return 1;
    1985                 :            :         }
    1986         [ #  # ]:          0 :         Py_DECREF(w);
    1987                 :          0 :         _PyErr_Format(tstate, PyExc_ValueError,
    1988                 :            :                       "too many values to unpack (expected %d)",
    1989                 :            :                       argcnt);
    1990                 :          0 :         goto Error;
    1991                 :            :     }
    1992                 :            : 
    1993                 :       1994 :     l = PySequence_List(it);
    1994         [ -  + ]:       1994 :     if (l == NULL)
    1995                 :          0 :         goto Error;
    1996                 :       1994 :     *--sp = l;
    1997                 :       1994 :     i++;
    1998                 :            : 
    1999                 :       1994 :     ll = PyList_GET_SIZE(l);
    2000         [ -  + ]:       1994 :     if (ll < argcntafter) {
    2001                 :          0 :         _PyErr_Format(tstate, PyExc_ValueError,
    2002                 :            :             "not enough values to unpack (expected at least %d, got %zd)",
    2003                 :            :             argcnt + argcntafter, argcnt + ll);
    2004                 :          0 :         goto Error;
    2005                 :            :     }
    2006                 :            : 
    2007                 :            :     /* Pop the "after-variable" args off the list. */
    2008         [ -  + ]:       1994 :     for (j = argcntafter; j > 0; j--, i++) {
    2009                 :          0 :         *--sp = PyList_GET_ITEM(l, ll - j);
    2010                 :            :     }
    2011                 :            :     /* Resize the list. */
    2012                 :       1994 :     Py_SET_SIZE(l, ll - argcntafter);
    2013         [ +  - ]:       1994 :     Py_DECREF(it);
    2014                 :       1994 :     return 1;
    2015                 :            : 
    2016                 :          0 : Error:
    2017         [ #  # ]:          0 :     for (; i > 0; i--, sp++)
    2018         [ #  # ]:          0 :         Py_DECREF(*sp);
    2019   [ #  #  #  # ]:          0 :     Py_XDECREF(it);
    2020                 :          0 :     return 0;
    2021                 :            : }
    2022                 :            : 
    2023                 :            : static void
    2024                 :          0 : call_exc_trace(Py_tracefunc func, PyObject *self,
    2025                 :            :                PyThreadState *tstate,
    2026                 :            :                _PyInterpreterFrame *f)
    2027                 :            : {
    2028                 :          0 :     PyObject *exc = _PyErr_GetRaisedException(tstate);
    2029                 :            :     assert(exc && PyExceptionInstance_Check(exc));
    2030                 :          0 :     PyObject *type = PyExceptionInstance_Class(exc);
    2031                 :          0 :     PyObject *traceback = PyException_GetTraceback(exc);
    2032         [ #  # ]:          0 :     if (traceback == NULL) {
    2033                 :          0 :         traceback = Py_NewRef(Py_None);
    2034                 :            :     }
    2035                 :          0 :     PyObject *arg = PyTuple_Pack(3, type, exc, traceback);
    2036   [ #  #  #  # ]:          0 :     Py_XDECREF(traceback);
    2037                 :            : 
    2038         [ #  # ]:          0 :     if (arg == NULL) {
    2039                 :          0 :         _PyErr_SetRaisedException(tstate, exc);
    2040                 :          0 :         return;
    2041                 :            :     }
    2042                 :          0 :     int err = call_trace(func, self, tstate, f, PyTrace_EXCEPTION, arg);
    2043         [ #  # ]:          0 :     Py_DECREF(arg);
    2044         [ #  # ]:          0 :     if (err == 0) {
    2045                 :          0 :         _PyErr_SetRaisedException(tstate, exc);
    2046                 :            :     }
    2047                 :            :     else {
    2048   [ #  #  #  # ]:          0 :         Py_XDECREF(exc);
    2049                 :            :     }
    2050                 :            : }
    2051                 :            : 
    2052                 :            : static int
    2053                 :          0 : call_trace_protected(Py_tracefunc func, PyObject *obj,
    2054                 :            :                      PyThreadState *tstate, _PyInterpreterFrame *frame,
    2055                 :            :                      int what, PyObject *arg)
    2056                 :            : {
    2057                 :          0 :     PyObject *exc = _PyErr_GetRaisedException(tstate);
    2058                 :          0 :     int err = call_trace(func, obj, tstate, frame, what, arg);
    2059         [ #  # ]:          0 :     if (err == 0)
    2060                 :            :     {
    2061                 :          0 :         _PyErr_SetRaisedException(tstate, exc);
    2062                 :          0 :         return 0;
    2063                 :            :     }
    2064                 :            :     else {
    2065   [ #  #  #  # ]:          0 :         Py_XDECREF(exc);
    2066                 :          0 :         return -1;
    2067                 :            :     }
    2068                 :            : }
    2069                 :            : 
    2070                 :            : static void
    2071                 :          0 : initialize_trace_info(PyTraceInfo *trace_info, _PyInterpreterFrame *frame)
    2072                 :            : {
    2073                 :          0 :     PyCodeObject *code = frame->f_code;
    2074         [ #  # ]:          0 :     if (trace_info->code != code) {
    2075                 :          0 :         trace_info->code = code;
    2076                 :          0 :         _PyCode_InitAddressRange(code, &trace_info->bounds);
    2077                 :            :     }
    2078                 :          0 : }
    2079                 :            : 
    2080                 :            : void
    2081                 :        637 : PyThreadState_EnterTracing(PyThreadState *tstate)
    2082                 :            : {
    2083                 :        637 :     tstate->tracing++;
    2084                 :        637 :     tstate->cframe->use_tracing = 0;
    2085                 :        637 : }
    2086                 :            : 
    2087                 :            : void
    2088                 :        637 : PyThreadState_LeaveTracing(PyThreadState *tstate)
    2089                 :            : {
    2090                 :            :     assert(tstate->tracing > 0 && tstate->cframe->use_tracing == 0);
    2091                 :        637 :     tstate->tracing--;
    2092                 :        637 :     _PyThreadState_UpdateTracingState(tstate);
    2093                 :        637 : }
    2094                 :            : 
    2095                 :            : static int
    2096                 :          0 : call_trace(Py_tracefunc func, PyObject *obj,
    2097                 :            :            PyThreadState *tstate, _PyInterpreterFrame *frame,
    2098                 :            :            int what, PyObject *arg)
    2099                 :            : {
    2100                 :            :     int result;
    2101         [ #  # ]:          0 :     if (tstate->tracing) {
    2102                 :          0 :         return 0;
    2103                 :            :     }
    2104                 :          0 :     PyFrameObject *f = _PyFrame_GetFrameObject(frame);
    2105         [ #  # ]:          0 :     if (f == NULL) {
    2106                 :          0 :         return -1;
    2107                 :            :     }
    2108                 :          0 :     int old_what = tstate->tracing_what;
    2109                 :          0 :     tstate->tracing_what = what;
    2110                 :          0 :     PyThreadState_EnterTracing(tstate);
    2111                 :            :     assert(_PyInterpreterFrame_LASTI(frame) >= 0);
    2112         [ #  # ]:          0 :     if (_PyCode_InitLineArray(frame->f_code)) {
    2113                 :          0 :         return -1;
    2114                 :            :     }
    2115                 :          0 :     f->f_lineno = _PyCode_LineNumberFromArray(frame->f_code, _PyInterpreterFrame_LASTI(frame));
    2116                 :          0 :     result = func(obj, f, what, arg);
    2117                 :          0 :     f->f_lineno = 0;
    2118                 :          0 :     PyThreadState_LeaveTracing(tstate);
    2119                 :          0 :     tstate->tracing_what = old_what;
    2120                 :          0 :     return result;
    2121                 :            : }
    2122                 :            : 
    2123                 :            : PyObject*
    2124                 :          0 : _PyEval_CallTracing(PyObject *func, PyObject *args)
    2125                 :            : {
    2126                 :            :     // Save and disable tracing
    2127                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2128                 :          0 :     int save_tracing = tstate->tracing;
    2129                 :          0 :     int save_use_tracing = tstate->cframe->use_tracing;
    2130                 :          0 :     tstate->tracing = 0;
    2131                 :            : 
    2132                 :            :     // Call the tracing function
    2133                 :          0 :     PyObject *result = PyObject_Call(func, args, NULL);
    2134                 :            : 
    2135                 :            :     // Restore tracing
    2136                 :          0 :     tstate->tracing = save_tracing;
    2137                 :          0 :     tstate->cframe->use_tracing = save_use_tracing;
    2138                 :          0 :     return result;
    2139                 :            : }
    2140                 :            : 
    2141                 :            : /* See Objects/lnotab_notes.txt for a description of how tracing works. */
    2142                 :            : static int
    2143                 :          0 : maybe_call_line_trace(Py_tracefunc func, PyObject *obj,
    2144                 :            :                       PyThreadState *tstate, _PyInterpreterFrame *frame, int instr_prev)
    2145                 :            : {
    2146                 :          0 :     int result = 0;
    2147                 :            : 
    2148                 :            :     /* If the last instruction falls at the start of a line or if it
    2149                 :            :        represents a jump backwards, update the frame's line number and
    2150                 :            :        then call the trace function if we're tracing source lines.
    2151                 :            :     */
    2152         [ #  # ]:          0 :     if (_PyCode_InitLineArray(frame->f_code)) {
    2153                 :          0 :         return -1;
    2154                 :            :     }
    2155                 :            :     int lastline;
    2156         [ #  # ]:          0 :     if (instr_prev <= frame->f_code->_co_firsttraceable) {
    2157                 :          0 :         lastline = -1;
    2158                 :            :     }
    2159                 :            :     else {
    2160                 :          0 :         lastline = _PyCode_LineNumberFromArray(frame->f_code, instr_prev);
    2161                 :            :     }
    2162                 :          0 :     int line = _PyCode_LineNumberFromArray(frame->f_code, _PyInterpreterFrame_LASTI(frame));
    2163                 :          0 :     PyFrameObject *f = _PyFrame_GetFrameObject(frame);
    2164         [ #  # ]:          0 :     if (f == NULL) {
    2165                 :          0 :         return -1;
    2166                 :            :     }
    2167   [ #  #  #  # ]:          0 :     if (line != -1 && f->f_trace_lines) {
    2168                 :            :         /* Trace backward edges (except in 'yield from') or if line number has changed */
    2169         [ #  # ]:          0 :         int trace = line != lastline ||
    2170         [ #  # ]:          0 :             (_PyInterpreterFrame_LASTI(frame) < instr_prev &&
    2171                 :            :              // SEND has no quickened forms, so no need to use _PyOpcode_Deopt
    2172                 :            :              // here:
    2173         [ #  # ]:          0 :              frame->prev_instr->op.code != SEND);
    2174         [ #  # ]:          0 :         if (trace) {
    2175                 :          0 :             result = call_trace(func, obj, tstate, frame, PyTrace_LINE, Py_None);
    2176                 :            :         }
    2177                 :            :     }
    2178                 :            :     /* Always emit an opcode event if we're tracing all opcodes. */
    2179   [ #  #  #  # ]:          0 :     if (f->f_trace_opcodes && result == 0) {
    2180                 :          0 :         result = call_trace(func, obj, tstate, frame, PyTrace_OPCODE, Py_None);
    2181                 :            :     }
    2182                 :          0 :     return result;
    2183                 :            : }
    2184                 :            : 
    2185                 :            : int
    2186                 :          0 : _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
    2187                 :            : {
    2188                 :            :     assert(is_tstate_valid(tstate));
    2189                 :            :     /* The caller must hold the GIL */
    2190                 :            :     assert(PyGILState_Check());
    2191                 :            : 
    2192                 :            :     /* Call _PySys_Audit() in the context of the current thread state,
    2193                 :            :        even if tstate is not the current thread state. */
    2194                 :          0 :     PyThreadState *current_tstate = _PyThreadState_GET();
    2195         [ #  # ]:          0 :     if (_PySys_Audit(current_tstate, "sys.setprofile", NULL) < 0) {
    2196                 :          0 :         return -1;
    2197                 :            :     }
    2198                 :            : 
    2199                 :          0 :     tstate->c_profilefunc = func;
    2200                 :          0 :     PyObject *old_profileobj = tstate->c_profileobj;
    2201                 :          0 :     tstate->c_profileobj = Py_XNewRef(arg);
    2202                 :            :     /* Flag that tracing or profiling is turned on */
    2203                 :          0 :     _PyThreadState_UpdateTracingState(tstate);
    2204                 :            : 
    2205                 :            :     // gh-98257: Only call Py_XDECREF() once the new profile function is fully
    2206                 :            :     // set, so it's safe to call sys.setprofile() again (reentrant call).
    2207   [ #  #  #  # ]:          0 :     Py_XDECREF(old_profileobj);
    2208                 :            : 
    2209                 :          0 :     return 0;
    2210                 :            : }
    2211                 :            : 
    2212                 :            : void
    2213                 :          0 : PyEval_SetProfile(Py_tracefunc func, PyObject *arg)
    2214                 :            : {
    2215                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2216         [ #  # ]:          0 :     if (_PyEval_SetProfile(tstate, func, arg) < 0) {
    2217                 :            :         /* Log _PySys_Audit() error */
    2218                 :          0 :         _PyErr_WriteUnraisableMsg("in PyEval_SetProfile", NULL);
    2219                 :            :     }
    2220                 :          0 : }
    2221                 :            : 
    2222                 :            : void
    2223                 :          0 : PyEval_SetProfileAllThreads(Py_tracefunc func, PyObject *arg)
    2224                 :            : {
    2225                 :          0 :     PyThreadState *this_tstate = _PyThreadState_GET();
    2226                 :          0 :     PyInterpreterState* interp = this_tstate->interp;
    2227                 :            : 
    2228                 :          0 :     _PyRuntimeState *runtime = &_PyRuntime;
    2229                 :          0 :     HEAD_LOCK(runtime);
    2230                 :          0 :     PyThreadState* ts = PyInterpreterState_ThreadHead(interp);
    2231                 :          0 :     HEAD_UNLOCK(runtime);
    2232                 :            : 
    2233         [ #  # ]:          0 :     while (ts) {
    2234         [ #  # ]:          0 :         if (_PyEval_SetProfile(ts, func, arg) < 0) {
    2235                 :          0 :             _PyErr_WriteUnraisableMsg("in PyEval_SetProfileAllThreads", NULL);
    2236                 :            :         }
    2237                 :          0 :         HEAD_LOCK(runtime);
    2238                 :          0 :         ts = PyThreadState_Next(ts);
    2239                 :          0 :         HEAD_UNLOCK(runtime);
    2240                 :            :     }
    2241                 :          0 : }
    2242                 :            : 
    2243                 :            : int
    2244                 :          1 : _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
    2245                 :            : {
    2246                 :            :     assert(is_tstate_valid(tstate));
    2247                 :            :     /* The caller must hold the GIL */
    2248                 :            :     assert(PyGILState_Check());
    2249                 :            : 
    2250                 :            :     /* Call _PySys_Audit() in the context of the current thread state,
    2251                 :            :        even if tstate is not the current thread state. */
    2252                 :          1 :     PyThreadState *current_tstate = _PyThreadState_GET();
    2253         [ -  + ]:          1 :     if (_PySys_Audit(current_tstate, "sys.settrace", NULL) < 0) {
    2254                 :          0 :         return -1;
    2255                 :            :     }
    2256                 :            : 
    2257                 :          1 :     tstate->c_tracefunc = func;
    2258                 :          1 :     PyObject *old_traceobj = tstate->c_traceobj;
    2259                 :          1 :     tstate->c_traceobj = Py_XNewRef(arg);
    2260                 :            :     /* Flag that tracing or profiling is turned on */
    2261                 :          1 :     _PyThreadState_UpdateTracingState(tstate);
    2262                 :            : 
    2263                 :            :     // gh-98257: Only call Py_XDECREF() once the new trace function is fully
    2264                 :            :     // set, so it's safe to call sys.settrace() again (reentrant call).
    2265   [ -  +  -  - ]:          1 :     Py_XDECREF(old_traceobj);
    2266                 :            : 
    2267                 :          1 :     return 0;
    2268                 :            : }
    2269                 :            : 
    2270                 :            : void
    2271                 :          0 : PyEval_SetTrace(Py_tracefunc func, PyObject *arg)
    2272                 :            : {
    2273                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2274         [ #  # ]:          0 :     if (_PyEval_SetTrace(tstate, func, arg) < 0) {
    2275                 :            :         /* Log _PySys_Audit() error */
    2276                 :          0 :         _PyErr_WriteUnraisableMsg("in PyEval_SetTrace", NULL);
    2277                 :            :     }
    2278                 :          0 : }
    2279                 :            : 
    2280                 :            : void
    2281                 :          0 : PyEval_SetTraceAllThreads(Py_tracefunc func, PyObject *arg)
    2282                 :            : {
    2283                 :          0 :     PyThreadState *this_tstate = _PyThreadState_GET();
    2284                 :          0 :     PyInterpreterState* interp = this_tstate->interp;
    2285                 :            : 
    2286                 :          0 :     _PyRuntimeState *runtime = &_PyRuntime;
    2287                 :          0 :     HEAD_LOCK(runtime);
    2288                 :          0 :     PyThreadState* ts = PyInterpreterState_ThreadHead(interp);
    2289                 :          0 :     HEAD_UNLOCK(runtime);
    2290                 :            : 
    2291         [ #  # ]:          0 :     while (ts) {
    2292         [ #  # ]:          0 :         if (_PyEval_SetTrace(ts, func, arg) < 0) {
    2293                 :          0 :             _PyErr_WriteUnraisableMsg("in PyEval_SetTraceAllThreads", NULL);
    2294                 :            :         }
    2295                 :          0 :         HEAD_LOCK(runtime);
    2296                 :          0 :         ts = PyThreadState_Next(ts);
    2297                 :          0 :         HEAD_UNLOCK(runtime);
    2298                 :            :     }
    2299                 :          0 : }
    2300                 :            : 
    2301                 :            : int
    2302                 :          0 : _PyEval_SetCoroutineOriginTrackingDepth(int depth)
    2303                 :            : {
    2304                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2305         [ #  # ]:          0 :     if (depth < 0) {
    2306                 :          0 :         _PyErr_SetString(tstate, PyExc_ValueError, "depth must be >= 0");
    2307                 :          0 :         return -1;
    2308                 :            :     }
    2309                 :          0 :     tstate->coroutine_origin_tracking_depth = depth;
    2310                 :          0 :     return 0;
    2311                 :            : }
    2312                 :            : 
    2313                 :            : 
    2314                 :            : int
    2315                 :          0 : _PyEval_GetCoroutineOriginTrackingDepth(void)
    2316                 :            : {
    2317                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2318                 :          0 :     return tstate->coroutine_origin_tracking_depth;
    2319                 :            : }
    2320                 :            : 
    2321                 :            : int
    2322                 :          0 : _PyEval_SetAsyncGenFirstiter(PyObject *firstiter)
    2323                 :            : {
    2324                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2325                 :            : 
    2326         [ #  # ]:          0 :     if (_PySys_Audit(tstate, "sys.set_asyncgen_hook_firstiter", NULL) < 0) {
    2327                 :          0 :         return -1;
    2328                 :            :     }
    2329                 :            : 
    2330   [ #  #  #  # ]:          0 :     Py_XSETREF(tstate->async_gen_firstiter, Py_XNewRef(firstiter));
    2331                 :          0 :     return 0;
    2332                 :            : }
    2333                 :            : 
    2334                 :            : PyObject *
    2335                 :          0 : _PyEval_GetAsyncGenFirstiter(void)
    2336                 :            : {
    2337                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2338                 :          0 :     return tstate->async_gen_firstiter;
    2339                 :            : }
    2340                 :            : 
    2341                 :            : int
    2342                 :          0 : _PyEval_SetAsyncGenFinalizer(PyObject *finalizer)
    2343                 :            : {
    2344                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2345                 :            : 
    2346         [ #  # ]:          0 :     if (_PySys_Audit(tstate, "sys.set_asyncgen_hook_finalizer", NULL) < 0) {
    2347                 :          0 :         return -1;
    2348                 :            :     }
    2349                 :            : 
    2350   [ #  #  #  # ]:          0 :     Py_XSETREF(tstate->async_gen_finalizer, Py_XNewRef(finalizer));
    2351                 :          0 :     return 0;
    2352                 :            : }
    2353                 :            : 
    2354                 :            : PyObject *
    2355                 :          0 : _PyEval_GetAsyncGenFinalizer(void)
    2356                 :            : {
    2357                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2358                 :          0 :     return tstate->async_gen_finalizer;
    2359                 :            : }
    2360                 :            : 
    2361                 :            : _PyInterpreterFrame *
    2362                 :          0 : _PyEval_GetFrame(void)
    2363                 :            : {
    2364                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2365                 :          0 :     return _PyThreadState_GetFrame(tstate);
    2366                 :            : }
    2367                 :            : 
    2368                 :            : PyFrameObject *
    2369                 :          0 : PyEval_GetFrame(void)
    2370                 :            : {
    2371                 :          0 :     _PyInterpreterFrame *frame = _PyEval_GetFrame();
    2372         [ #  # ]:          0 :     if (frame == NULL) {
    2373                 :          0 :         return NULL;
    2374                 :            :     }
    2375                 :          0 :     PyFrameObject *f = _PyFrame_GetFrameObject(frame);
    2376         [ #  # ]:          0 :     if (f == NULL) {
    2377                 :          0 :         PyErr_Clear();
    2378                 :            :     }
    2379                 :          0 :     return f;
    2380                 :            : }
    2381                 :            : 
    2382                 :            : PyObject *
    2383                 :        692 : _PyEval_GetBuiltins(PyThreadState *tstate)
    2384                 :            : {
    2385                 :        692 :     _PyInterpreterFrame *frame = _PyThreadState_GetFrame(tstate);
    2386         [ +  + ]:        692 :     if (frame != NULL) {
    2387                 :        642 :         return frame->f_builtins;
    2388                 :            :     }
    2389                 :         50 :     return tstate->interp->builtins;
    2390                 :            : }
    2391                 :            : 
    2392                 :            : PyObject *
    2393                 :        692 : PyEval_GetBuiltins(void)
    2394                 :            : {
    2395                 :        692 :     PyThreadState *tstate = _PyThreadState_GET();
    2396                 :        692 :     return _PyEval_GetBuiltins(tstate);
    2397                 :            : }
    2398                 :            : 
    2399                 :            : /* Convenience function to get a builtin from its name */
    2400                 :            : PyObject *
    2401                 :          1 : _PyEval_GetBuiltin(PyObject *name)
    2402                 :            : {
    2403                 :          1 :     PyThreadState *tstate = _PyThreadState_GET();
    2404                 :          1 :     PyObject *attr = PyDict_GetItemWithError(PyEval_GetBuiltins(), name);
    2405         [ +  - ]:          1 :     if (attr) {
    2406                 :          1 :         Py_INCREF(attr);
    2407                 :            :     }
    2408         [ #  # ]:          0 :     else if (!_PyErr_Occurred(tstate)) {
    2409                 :          0 :         _PyErr_SetObject(tstate, PyExc_AttributeError, name);
    2410                 :            :     }
    2411                 :          1 :     return attr;
    2412                 :            : }
    2413                 :            : 
    2414                 :            : PyObject *
    2415                 :          0 : _PyEval_GetBuiltinId(_Py_Identifier *name)
    2416                 :            : {
    2417                 :          0 :     return _PyEval_GetBuiltin(_PyUnicode_FromId(name));
    2418                 :            : }
    2419                 :            : 
    2420                 :            : PyObject *
    2421                 :          2 : PyEval_GetLocals(void)
    2422                 :            : {
    2423                 :          2 :     PyThreadState *tstate = _PyThreadState_GET();
    2424                 :          2 :      _PyInterpreterFrame *current_frame = _PyThreadState_GetFrame(tstate);
    2425         [ -  + ]:          2 :     if (current_frame == NULL) {
    2426                 :          0 :         _PyErr_SetString(tstate, PyExc_SystemError, "frame does not exist");
    2427                 :          0 :         return NULL;
    2428                 :            :     }
    2429                 :            : 
    2430         [ -  + ]:          2 :     if (_PyFrame_FastToLocalsWithError(current_frame) < 0) {
    2431                 :          0 :         return NULL;
    2432                 :            :     }
    2433                 :            : 
    2434                 :          2 :     PyObject *locals = current_frame->f_locals;
    2435                 :            :     assert(locals != NULL);
    2436                 :          2 :     return locals;
    2437                 :            : }
    2438                 :            : 
    2439                 :            : PyObject *
    2440                 :       1357 : PyEval_GetGlobals(void)
    2441                 :            : {
    2442                 :       1357 :     PyThreadState *tstate = _PyThreadState_GET();
    2443                 :       1357 :     _PyInterpreterFrame *current_frame = _PyThreadState_GetFrame(tstate);
    2444         [ +  + ]:       1357 :     if (current_frame == NULL) {
    2445                 :        180 :         return NULL;
    2446                 :            :     }
    2447                 :       1177 :     return current_frame->f_globals;
    2448                 :            : }
    2449                 :            : 
    2450                 :            : int
    2451                 :         89 : PyEval_MergeCompilerFlags(PyCompilerFlags *cf)
    2452                 :            : {
    2453                 :         89 :     PyThreadState *tstate = _PyThreadState_GET();
    2454                 :         89 :     _PyInterpreterFrame *current_frame = tstate->cframe->current_frame;
    2455                 :         89 :     int result = cf->cf_flags != 0;
    2456                 :            : 
    2457         [ +  - ]:         89 :     if (current_frame != NULL) {
    2458                 :         89 :         const int codeflags = current_frame->f_code->co_flags;
    2459                 :         89 :         const int compilerflags = codeflags & PyCF_MASK;
    2460         [ -  + ]:         89 :         if (compilerflags) {
    2461                 :          0 :             result = 1;
    2462                 :          0 :             cf->cf_flags |= compilerflags;
    2463                 :            :         }
    2464                 :            :     }
    2465                 :         89 :     return result;
    2466                 :            : }
    2467                 :            : 
    2468                 :            : 
    2469                 :            : const char *
    2470                 :          0 : PyEval_GetFuncName(PyObject *func)
    2471                 :            : {
    2472         [ #  # ]:          0 :     if (PyMethod_Check(func))
    2473                 :          0 :         return PyEval_GetFuncName(PyMethod_GET_FUNCTION(func));
    2474         [ #  # ]:          0 :     else if (PyFunction_Check(func))
    2475                 :          0 :         return PyUnicode_AsUTF8(((PyFunctionObject*)func)->func_name);
    2476         [ #  # ]:          0 :     else if (PyCFunction_Check(func))
    2477                 :          0 :         return ((PyCFunctionObject*)func)->m_ml->ml_name;
    2478                 :            :     else
    2479                 :          0 :         return Py_TYPE(func)->tp_name;
    2480                 :            : }
    2481                 :            : 
    2482                 :            : const char *
    2483                 :          0 : PyEval_GetFuncDesc(PyObject *func)
    2484                 :            : {
    2485         [ #  # ]:          0 :     if (PyMethod_Check(func))
    2486                 :          0 :         return "()";
    2487         [ #  # ]:          0 :     else if (PyFunction_Check(func))
    2488                 :          0 :         return "()";
    2489         [ #  # ]:          0 :     else if (PyCFunction_Check(func))
    2490                 :          0 :         return "()";
    2491                 :            :     else
    2492                 :          0 :         return " object";
    2493                 :            : }
    2494                 :            : 
    2495                 :            : #define C_TRACE(x, call) \
    2496                 :            : if (use_tracing && tstate->c_profilefunc) { \
    2497                 :            :     if (call_trace(tstate->c_profilefunc, tstate->c_profileobj, \
    2498                 :            :         tstate, tstate->cframe->current_frame, \
    2499                 :            :         PyTrace_C_CALL, func)) { \
    2500                 :            :         x = NULL; \
    2501                 :            :     } \
    2502                 :            :     else { \
    2503                 :            :         x = call; \
    2504                 :            :         if (tstate->c_profilefunc != NULL) { \
    2505                 :            :             if (x == NULL) { \
    2506                 :            :                 call_trace_protected(tstate->c_profilefunc, \
    2507                 :            :                     tstate->c_profileobj, \
    2508                 :            :                     tstate, tstate->cframe->current_frame, \
    2509                 :            :                     PyTrace_C_EXCEPTION, func); \
    2510                 :            :                 /* XXX should pass (type, value, tb) */ \
    2511                 :            :             } else { \
    2512                 :            :                 if (call_trace(tstate->c_profilefunc, \
    2513                 :            :                     tstate->c_profileobj, \
    2514                 :            :                     tstate, tstate->cframe->current_frame, \
    2515                 :            :                     PyTrace_C_RETURN, func)) { \
    2516                 :            :                     Py_DECREF(x); \
    2517                 :            :                     x = NULL; \
    2518                 :            :                 } \
    2519                 :            :             } \
    2520                 :            :         } \
    2521                 :            :     } \
    2522                 :            : } else { \
    2523                 :            :     x = call; \
    2524                 :            :     }
    2525                 :            : 
    2526                 :            : 
    2527                 :            : static PyObject *
    2528                 :          0 : trace_call_function(PyThreadState *tstate,
    2529                 :            :                     PyObject *func,
    2530                 :            :                     PyObject **args, Py_ssize_t nargs,
    2531                 :            :                     PyObject *kwnames)
    2532                 :            : {
    2533                 :          0 :     int use_tracing = 1;
    2534                 :            :     PyObject *x;
    2535   [ #  #  #  # ]:          0 :     if (PyCFunction_CheckExact(func) || PyCMethod_CheckExact(func)) {
    2536   [ #  #  #  #  :          0 :         C_TRACE(x, PyObject_Vectorcall(func, args, nargs, kwnames));
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    2537                 :          0 :         return x;
    2538                 :            :     }
    2539   [ #  #  #  # ]:          0 :     else if (Py_IS_TYPE(func, &PyMethodDescr_Type) && nargs > 0) {
    2540                 :            :         /* We need to create a temporary bound method as argument
    2541                 :            :            for profiling.
    2542                 :            : 
    2543                 :            :            If nargs == 0, then this cannot work because we have no
    2544                 :            :            "self". In any case, the call itself would raise
    2545                 :            :            TypeError (foo needs an argument), so we just skip
    2546                 :            :            profiling. */
    2547                 :          0 :         PyObject *self = args[0];
    2548                 :          0 :         func = Py_TYPE(func)->tp_descr_get(func, self, (PyObject*)Py_TYPE(self));
    2549         [ #  # ]:          0 :         if (func == NULL) {
    2550                 :          0 :             return NULL;
    2551                 :            :         }
    2552   [ #  #  #  #  :          0 :         C_TRACE(x, PyObject_Vectorcall(func,
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    2553                 :            :                                         args+1, nargs-1,
    2554                 :            :                                         kwnames));
    2555         [ #  # ]:          0 :         Py_DECREF(func);
    2556                 :          0 :         return x;
    2557                 :            :     }
    2558                 :          0 :     return PyObject_Vectorcall(func, args, nargs | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames);
    2559                 :            : }
    2560                 :            : 
    2561                 :            : static PyObject *
    2562                 :     103224 : do_call_core(PyThreadState *tstate,
    2563                 :            :              PyObject *func,
    2564                 :            :              PyObject *callargs,
    2565                 :            :              PyObject *kwdict,
    2566                 :            :              int use_tracing
    2567                 :            :             )
    2568                 :            : {
    2569                 :            :     PyObject *result;
    2570   [ +  +  -  + ]:     103224 :     if (PyCFunction_CheckExact(func) || PyCMethod_CheckExact(func)) {
    2571   [ -  +  -  -  :       4197 :         C_TRACE(result, PyObject_Call(func, callargs, kwdict));
          -  -  -  -  -  
             -  -  -  -  
                      - ]
    2572                 :       4197 :         return result;
    2573                 :            :     }
    2574         [ -  + ]:      99027 :     else if (Py_IS_TYPE(func, &PyMethodDescr_Type)) {
    2575                 :          0 :         Py_ssize_t nargs = PyTuple_GET_SIZE(callargs);
    2576   [ #  #  #  # ]:          0 :         if (nargs > 0 && use_tracing) {
    2577                 :            :             /* We need to create a temporary bound method as argument
    2578                 :            :                for profiling.
    2579                 :            : 
    2580                 :            :                If nargs == 0, then this cannot work because we have no
    2581                 :            :                "self". In any case, the call itself would raise
    2582                 :            :                TypeError (foo needs an argument), so we just skip
    2583                 :            :                profiling. */
    2584                 :          0 :             PyObject *self = PyTuple_GET_ITEM(callargs, 0);
    2585                 :          0 :             func = Py_TYPE(func)->tp_descr_get(func, self, (PyObject*)Py_TYPE(self));
    2586         [ #  # ]:          0 :             if (func == NULL) {
    2587                 :          0 :                 return NULL;
    2588                 :            :             }
    2589                 :            : 
    2590   [ #  #  #  #  :          0 :             C_TRACE(result, _PyObject_FastCallDictTstate(
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    2591                 :            :                                     tstate, func,
    2592                 :            :                                     &_PyTuple_ITEMS(callargs)[1],
    2593                 :            :                                     nargs - 1,
    2594                 :            :                                     kwdict));
    2595         [ #  # ]:          0 :             Py_DECREF(func);
    2596                 :          0 :             return result;
    2597                 :            :         }
    2598                 :            :     }
    2599                 :            :     EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func);
    2600                 :      99027 :     return PyObject_Call(func, callargs, kwdict);
    2601                 :            : }
    2602                 :            : 
    2603                 :            : /* Extract a slice index from a PyLong or an object with the
    2604                 :            :    nb_index slot defined, and store in *pi.
    2605                 :            :    Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
    2606                 :            :    and silently boost values less than PY_SSIZE_T_MIN to PY_SSIZE_T_MIN.
    2607                 :            :    Return 0 on error, 1 on success.
    2608                 :            : */
    2609                 :            : int
    2610                 :     150047 : _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
    2611                 :            : {
    2612                 :     150047 :     PyThreadState *tstate = _PyThreadState_GET();
    2613         [ +  - ]:     150047 :     if (!Py_IsNone(v)) {
    2614                 :            :         Py_ssize_t x;
    2615         [ +  - ]:     150047 :         if (_PyIndex_Check(v)) {
    2616                 :     150047 :             x = PyNumber_AsSsize_t(v, NULL);
    2617   [ +  +  -  + ]:     150047 :             if (x == -1 && _PyErr_Occurred(tstate))
    2618                 :          0 :                 return 0;
    2619                 :            :         }
    2620                 :            :         else {
    2621                 :          0 :             _PyErr_SetString(tstate, PyExc_TypeError,
    2622                 :            :                              "slice indices must be integers or "
    2623                 :            :                              "None or have an __index__ method");
    2624                 :          0 :             return 0;
    2625                 :            :         }
    2626                 :     150047 :         *pi = x;
    2627                 :            :     }
    2628                 :     150047 :     return 1;
    2629                 :            : }
    2630                 :            : 
    2631                 :            : int
    2632                 :          0 : _PyEval_SliceIndexNotNone(PyObject *v, Py_ssize_t *pi)
    2633                 :            : {
    2634                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    2635                 :            :     Py_ssize_t x;
    2636         [ #  # ]:          0 :     if (_PyIndex_Check(v)) {
    2637                 :          0 :         x = PyNumber_AsSsize_t(v, NULL);
    2638   [ #  #  #  # ]:          0 :         if (x == -1 && _PyErr_Occurred(tstate))
    2639                 :          0 :             return 0;
    2640                 :            :     }
    2641                 :            :     else {
    2642                 :          0 :         _PyErr_SetString(tstate, PyExc_TypeError,
    2643                 :            :                          "slice indices must be integers or "
    2644                 :            :                          "have an __index__ method");
    2645                 :          0 :         return 0;
    2646                 :            :     }
    2647                 :          0 :     *pi = x;
    2648                 :          0 :     return 1;
    2649                 :            : }
    2650                 :            : 
    2651                 :            : static PyObject *
    2652                 :       3157 : import_name(PyThreadState *tstate, _PyInterpreterFrame *frame,
    2653                 :            :             PyObject *name, PyObject *fromlist, PyObject *level)
    2654                 :            : {
    2655                 :            :     PyObject *import_func, *res;
    2656                 :            :     PyObject* stack[5];
    2657                 :            : 
    2658                 :       3157 :     import_func = _PyDict_GetItemWithError(frame->f_builtins, &_Py_ID(__import__));
    2659         [ -  + ]:       3157 :     if (import_func == NULL) {
    2660         [ #  # ]:          0 :         if (!_PyErr_Occurred(tstate)) {
    2661                 :          0 :             _PyErr_SetString(tstate, PyExc_ImportError, "__import__ not found");
    2662                 :            :         }
    2663                 :          0 :         return NULL;
    2664                 :            :     }
    2665                 :       3157 :     PyObject *locals = frame->f_locals;
    2666                 :            :     /* Fast path for not overloaded __import__. */
    2667         [ +  - ]:       3157 :     if (_PyImport_IsDefaultImportFunc(tstate->interp, import_func)) {
    2668                 :       3157 :         int ilevel = _PyLong_AsInt(level);
    2669   [ -  +  -  - ]:       3157 :         if (ilevel == -1 && _PyErr_Occurred(tstate)) {
    2670                 :          0 :             return NULL;
    2671                 :            :         }
    2672         [ +  + ]:       3157 :         res = PyImport_ImportModuleLevelObject(
    2673                 :            :                         name,
    2674                 :            :                         frame->f_globals,
    2675                 :            :                         locals == NULL ? Py_None :locals,
    2676                 :            :                         fromlist,
    2677                 :            :                         ilevel);
    2678                 :       3157 :         return res;
    2679                 :            :     }
    2680                 :            : 
    2681                 :          0 :     Py_INCREF(import_func);
    2682                 :            : 
    2683                 :          0 :     stack[0] = name;
    2684                 :          0 :     stack[1] = frame->f_globals;
    2685         [ #  # ]:          0 :     stack[2] = locals == NULL ? Py_None : locals;
    2686                 :          0 :     stack[3] = fromlist;
    2687                 :          0 :     stack[4] = level;
    2688                 :          0 :     res = _PyObject_FastCall(import_func, stack, 5);
    2689         [ #  # ]:          0 :     Py_DECREF(import_func);
    2690                 :          0 :     return res;
    2691                 :            : }
    2692                 :            : 
    2693                 :            : static PyObject *
    2694                 :       2022 : import_from(PyThreadState *tstate, PyObject *v, PyObject *name)
    2695                 :            : {
    2696                 :            :     PyObject *x;
    2697                 :            :     PyObject *fullmodname, *pkgname, *pkgpath, *pkgname_or_unknown, *errmsg;
    2698                 :            : 
    2699         [ +  + ]:       2022 :     if (_PyObject_LookupAttr(v, name, &x) != 0) {
    2700                 :       1993 :         return x;
    2701                 :            :     }
    2702                 :            :     /* Issue #17636: in case this failed because of a circular relative
    2703                 :            :        import, try to fallback on reading the module directly from
    2704                 :            :        sys.modules. */
    2705                 :         29 :     pkgname = PyObject_GetAttr(v, &_Py_ID(__name__));
    2706         [ -  + ]:         29 :     if (pkgname == NULL) {
    2707                 :          0 :         goto error;
    2708                 :            :     }
    2709         [ -  + ]:         29 :     if (!PyUnicode_Check(pkgname)) {
    2710   [ #  #  #  # ]:          0 :         Py_CLEAR(pkgname);
    2711                 :          0 :         goto error;
    2712                 :            :     }
    2713                 :         29 :     fullmodname = PyUnicode_FromFormat("%U.%U", pkgname, name);
    2714         [ -  + ]:         29 :     if (fullmodname == NULL) {
    2715         [ #  # ]:          0 :         Py_DECREF(pkgname);
    2716                 :          0 :         return NULL;
    2717                 :            :     }
    2718                 :         29 :     x = PyImport_GetModule(fullmodname);
    2719         [ +  - ]:         29 :     Py_DECREF(fullmodname);
    2720   [ +  +  +  - ]:         29 :     if (x == NULL && !_PyErr_Occurred(tstate)) {
    2721                 :         28 :         goto error;
    2722                 :            :     }
    2723         [ -  + ]:          1 :     Py_DECREF(pkgname);
    2724                 :          1 :     return x;
    2725                 :         28 :  error:
    2726                 :         28 :     pkgpath = PyModule_GetFilenameObject(v);
    2727         [ -  + ]:         28 :     if (pkgname == NULL) {
    2728                 :          0 :         pkgname_or_unknown = PyUnicode_FromString("<unknown module name>");
    2729         [ #  # ]:          0 :         if (pkgname_or_unknown == NULL) {
    2730   [ #  #  #  # ]:          0 :             Py_XDECREF(pkgpath);
    2731                 :          0 :             return NULL;
    2732                 :            :         }
    2733                 :            :     } else {
    2734                 :         28 :         pkgname_or_unknown = pkgname;
    2735                 :            :     }
    2736                 :            : 
    2737   [ +  +  -  + ]:         28 :     if (pkgpath == NULL || !PyUnicode_Check(pkgpath)) {
    2738                 :         25 :         _PyErr_Clear(tstate);
    2739                 :         25 :         errmsg = PyUnicode_FromFormat(
    2740                 :            :             "cannot import name %R from %R (unknown location)",
    2741                 :            :             name, pkgname_or_unknown
    2742                 :            :         );
    2743                 :            :         /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */
    2744                 :         25 :         _PyErr_SetImportErrorWithNameFrom(errmsg, pkgname, NULL, name);
    2745                 :            :     }
    2746                 :            :     else {
    2747                 :          3 :         PyObject *spec = PyObject_GetAttr(v, &_Py_ID(__spec__));
    2748                 :          3 :         const char *fmt =
    2749                 :          3 :             _PyModuleSpec_IsInitializing(spec) ?
    2750                 :            :             "cannot import name %R from partially initialized module %R "
    2751         [ +  + ]:          3 :             "(most likely due to a circular import) (%S)" :
    2752                 :            :             "cannot import name %R from %R (%S)";
    2753   [ +  -  -  + ]:          3 :         Py_XDECREF(spec);
    2754                 :            : 
    2755                 :          3 :         errmsg = PyUnicode_FromFormat(fmt, name, pkgname_or_unknown, pkgpath);
    2756                 :            :         /* NULL checks for errmsg and pkgname done by PyErr_SetImportError. */
    2757                 :          3 :         _PyErr_SetImportErrorWithNameFrom(errmsg, pkgname, pkgpath, name);
    2758                 :            :     }
    2759                 :            : 
    2760   [ +  -  -  + ]:         28 :     Py_XDECREF(errmsg);
    2761   [ +  -  -  + ]:         28 :     Py_XDECREF(pkgname_or_unknown);
    2762   [ +  +  -  + ]:         28 :     Py_XDECREF(pkgpath);
    2763                 :         28 :     return NULL;
    2764                 :            : }
    2765                 :            : 
    2766                 :            : #define CANNOT_CATCH_MSG "catching classes that do not inherit from "\
    2767                 :            :                          "BaseException is not allowed"
    2768                 :            : 
    2769                 :            : #define CANNOT_EXCEPT_STAR_EG "catching ExceptionGroup with except* "\
    2770                 :            :                               "is not allowed. Use except instead."
    2771                 :            : 
    2772                 :            : static int
    2773                 :     101696 : check_except_type_valid(PyThreadState *tstate, PyObject* right)
    2774                 :            : {
    2775         [ +  + ]:     101696 :     if (PyTuple_Check(right)) {
    2776                 :            :         Py_ssize_t i, length;
    2777                 :        289 :         length = PyTuple_GET_SIZE(right);
    2778         [ +  + ]:        867 :         for (i = 0; i < length; i++) {
    2779                 :        578 :             PyObject *exc = PyTuple_GET_ITEM(right, i);
    2780   [ +  -  -  + ]:        578 :             if (!PyExceptionClass_Check(exc)) {
    2781                 :          0 :                 _PyErr_SetString(tstate, PyExc_TypeError,
    2782                 :            :                     CANNOT_CATCH_MSG);
    2783                 :          0 :                 return -1;
    2784                 :            :             }
    2785                 :            :         }
    2786                 :            :     }
    2787                 :            :     else {
    2788   [ +  -  -  + ]:     101407 :         if (!PyExceptionClass_Check(right)) {
    2789                 :          0 :             _PyErr_SetString(tstate, PyExc_TypeError,
    2790                 :            :                 CANNOT_CATCH_MSG);
    2791                 :          0 :             return -1;
    2792                 :            :         }
    2793                 :            :     }
    2794                 :     101696 :     return 0;
    2795                 :            : }
    2796                 :            : 
    2797                 :            : static int
    2798                 :          0 : check_except_star_type_valid(PyThreadState *tstate, PyObject* right)
    2799                 :            : {
    2800         [ #  # ]:          0 :     if (check_except_type_valid(tstate, right) < 0) {
    2801                 :          0 :         return -1;
    2802                 :            :     }
    2803                 :            : 
    2804                 :            :     /* reject except *ExceptionGroup */
    2805                 :            : 
    2806                 :          0 :     int is_subclass = 0;
    2807         [ #  # ]:          0 :     if (PyTuple_Check(right)) {
    2808                 :          0 :         Py_ssize_t length = PyTuple_GET_SIZE(right);
    2809         [ #  # ]:          0 :         for (Py_ssize_t i = 0; i < length; i++) {
    2810                 :          0 :             PyObject *exc = PyTuple_GET_ITEM(right, i);
    2811                 :          0 :             is_subclass = PyObject_IsSubclass(exc, PyExc_BaseExceptionGroup);
    2812         [ #  # ]:          0 :             if (is_subclass < 0) {
    2813                 :          0 :                 return -1;
    2814                 :            :             }
    2815         [ #  # ]:          0 :             if (is_subclass) {
    2816                 :          0 :                 break;
    2817                 :            :             }
    2818                 :            :         }
    2819                 :            :     }
    2820                 :            :     else {
    2821                 :          0 :         is_subclass = PyObject_IsSubclass(right, PyExc_BaseExceptionGroup);
    2822         [ #  # ]:          0 :         if (is_subclass < 0) {
    2823                 :          0 :             return -1;
    2824                 :            :         }
    2825                 :            :     }
    2826         [ #  # ]:          0 :     if (is_subclass) {
    2827                 :          0 :         _PyErr_SetString(tstate, PyExc_TypeError,
    2828                 :            :             CANNOT_EXCEPT_STAR_EG);
    2829                 :          0 :             return -1;
    2830                 :            :     }
    2831                 :          0 :     return 0;
    2832                 :            : }
    2833                 :            : 
    2834                 :            : static int
    2835                 :        302 : check_args_iterable(PyThreadState *tstate, PyObject *func, PyObject *args)
    2836                 :            : {
    2837   [ -  +  -  - ]:        302 :     if (Py_TYPE(args)->tp_iter == NULL && !PySequence_Check(args)) {
    2838                 :            :         /* check_args_iterable() may be called with a live exception:
    2839                 :            :          * clear it to prevent calling _PyObject_FunctionStr() with an
    2840                 :            :          * exception set. */
    2841                 :          0 :         _PyErr_Clear(tstate);
    2842                 :          0 :         PyObject *funcstr = _PyObject_FunctionStr(func);
    2843         [ #  # ]:          0 :         if (funcstr != NULL) {
    2844                 :          0 :             _PyErr_Format(tstate, PyExc_TypeError,
    2845                 :            :                           "%U argument after * must be an iterable, not %.200s",
    2846                 :          0 :                           funcstr, Py_TYPE(args)->tp_name);
    2847         [ #  # ]:          0 :             Py_DECREF(funcstr);
    2848                 :            :         }
    2849                 :          0 :         return -1;
    2850                 :            :     }
    2851                 :        302 :     return 0;
    2852                 :            : }
    2853                 :            : 
    2854                 :            : static void
    2855                 :          0 : format_kwargs_error(PyThreadState *tstate, PyObject *func, PyObject *kwargs)
    2856                 :            : {
    2857                 :            :     /* _PyDict_MergeEx raises attribute
    2858                 :            :      * error (percolated from an attempt
    2859                 :            :      * to get 'keys' attribute) instead of
    2860                 :            :      * a type error if its second argument
    2861                 :            :      * is not a mapping.
    2862                 :            :      */
    2863         [ #  # ]:          0 :     if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {
    2864                 :          0 :         _PyErr_Clear(tstate);
    2865                 :          0 :         PyObject *funcstr = _PyObject_FunctionStr(func);
    2866         [ #  # ]:          0 :         if (funcstr != NULL) {
    2867                 :          0 :             _PyErr_Format(
    2868                 :            :                 tstate, PyExc_TypeError,
    2869                 :            :                 "%U argument after ** must be a mapping, not %.200s",
    2870                 :          0 :                 funcstr, Py_TYPE(kwargs)->tp_name);
    2871         [ #  # ]:          0 :             Py_DECREF(funcstr);
    2872                 :            :         }
    2873                 :            :     }
    2874         [ #  # ]:          0 :     else if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
    2875                 :          0 :         PyObject *exc = _PyErr_GetRaisedException(tstate);
    2876                 :          0 :         PyObject *args = ((PyBaseExceptionObject *)exc)->args;
    2877   [ #  #  #  #  :          0 :         if (exc && PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1) {
                   #  # ]
    2878                 :          0 :             _PyErr_Clear(tstate);
    2879                 :          0 :             PyObject *funcstr = _PyObject_FunctionStr(func);
    2880         [ #  # ]:          0 :             if (funcstr != NULL) {
    2881                 :          0 :                 PyObject *key = PyTuple_GET_ITEM(args, 0);
    2882                 :          0 :                 _PyErr_Format(
    2883                 :            :                     tstate, PyExc_TypeError,
    2884                 :            :                     "%U got multiple values for keyword argument '%S'",
    2885                 :            :                     funcstr, key);
    2886         [ #  # ]:          0 :                 Py_DECREF(funcstr);
    2887                 :            :             }
    2888   [ #  #  #  # ]:          0 :             Py_XDECREF(exc);
    2889                 :            :         }
    2890                 :            :         else {
    2891                 :          0 :             _PyErr_SetRaisedException(tstate, exc);
    2892                 :            :         }
    2893                 :            :     }
    2894                 :          0 : }
    2895                 :            : 
    2896                 :            : static void
    2897                 :          1 : format_exc_check_arg(PyThreadState *tstate, PyObject *exc,
    2898                 :            :                      const char *format_str, PyObject *obj)
    2899                 :            : {
    2900                 :            :     const char *obj_str;
    2901                 :            : 
    2902         [ -  + ]:          1 :     if (!obj)
    2903                 :          0 :         return;
    2904                 :            : 
    2905                 :          1 :     obj_str = PyUnicode_AsUTF8(obj);
    2906         [ -  + ]:          1 :     if (!obj_str)
    2907                 :          0 :         return;
    2908                 :            : 
    2909                 :          1 :     _PyErr_Format(tstate, exc, format_str, obj_str);
    2910                 :            : 
    2911         [ +  - ]:          1 :     if (exc == PyExc_NameError) {
    2912                 :            :         // Include the name in the NameError exceptions to offer suggestions later.
    2913                 :          1 :         PyObject *exc = PyErr_GetRaisedException();
    2914         [ +  - ]:          1 :         if (PyErr_GivenExceptionMatches(exc, PyExc_NameError)) {
    2915         [ +  - ]:          1 :             if (((PyNameErrorObject*)exc)->name == NULL) {
    2916                 :            :                 // We do not care if this fails because we are going to restore the
    2917                 :            :                 // NameError anyway.
    2918                 :          1 :                 (void)PyObject_SetAttr(exc, &_Py_ID(name), obj);
    2919                 :            :             }
    2920                 :            :         }
    2921                 :          1 :         PyErr_SetRaisedException(exc);
    2922                 :            :     }
    2923                 :            : }
    2924                 :            : 
    2925                 :            : static void
    2926                 :          0 : format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg)
    2927                 :            : {
    2928                 :            :     PyObject *name;
    2929                 :            :     /* Don't stomp existing exception */
    2930         [ #  # ]:          0 :     if (_PyErr_Occurred(tstate))
    2931                 :          0 :         return;
    2932                 :          0 :     name = PyTuple_GET_ITEM(co->co_localsplusnames, oparg);
    2933         [ #  # ]:          0 :     if (oparg < PyCode_GetFirstFree(co)) {
    2934                 :          0 :         format_exc_check_arg(tstate, PyExc_UnboundLocalError,
    2935                 :            :                              UNBOUNDLOCAL_ERROR_MSG, name);
    2936                 :            :     } else {
    2937                 :          0 :         format_exc_check_arg(tstate, PyExc_NameError,
    2938                 :            :                              UNBOUNDFREE_ERROR_MSG, name);
    2939                 :            :     }
    2940                 :            : }
    2941                 :            : 
    2942                 :            : static void
    2943                 :          0 : format_awaitable_error(PyThreadState *tstate, PyTypeObject *type, int oparg)
    2944                 :            : {
    2945   [ #  #  #  # ]:          0 :     if (type->tp_as_async == NULL || type->tp_as_async->am_await == NULL) {
    2946         [ #  # ]:          0 :         if (oparg == 1) {
    2947                 :          0 :             _PyErr_Format(tstate, PyExc_TypeError,
    2948                 :            :                           "'async with' received an object from __aenter__ "
    2949                 :            :                           "that does not implement __await__: %.100s",
    2950                 :            :                           type->tp_name);
    2951                 :            :         }
    2952         [ #  # ]:          0 :         else if (oparg == 2) {
    2953                 :          0 :             _PyErr_Format(tstate, PyExc_TypeError,
    2954                 :            :                           "'async with' received an object from __aexit__ "
    2955                 :            :                           "that does not implement __await__: %.100s",
    2956                 :            :                           type->tp_name);
    2957                 :            :         }
    2958                 :            :     }
    2959                 :          0 : }
    2960                 :            : 
    2961                 :            : 
    2962                 :            : Py_ssize_t
    2963                 :          0 : PyUnstable_Eval_RequestCodeExtraIndex(freefunc free)
    2964                 :            : {
    2965                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
    2966                 :            :     Py_ssize_t new_index;
    2967                 :            : 
    2968         [ #  # ]:          0 :     if (interp->co_extra_user_count == MAX_CO_EXTRA_USERS - 1) {
    2969                 :          0 :         return -1;
    2970                 :            :     }
    2971                 :          0 :     new_index = interp->co_extra_user_count++;
    2972                 :          0 :     interp->co_extra_freefuncs[new_index] = free;
    2973                 :          0 :     return new_index;
    2974                 :            : }
    2975                 :            : 
    2976                 :            : static void
    2977                 :          0 : dtrace_function_entry(_PyInterpreterFrame *frame)
    2978                 :            : {
    2979                 :            :     const char *filename;
    2980                 :            :     const char *funcname;
    2981                 :            :     int lineno;
    2982                 :            : 
    2983                 :          0 :     PyCodeObject *code = frame->f_code;
    2984                 :          0 :     filename = PyUnicode_AsUTF8(code->co_filename);
    2985                 :          0 :     funcname = PyUnicode_AsUTF8(code->co_name);
    2986                 :          0 :     lineno = _PyInterpreterFrame_GetLine(frame);
    2987                 :            : 
    2988                 :          0 :     PyDTrace_FUNCTION_ENTRY(filename, funcname, lineno);
    2989                 :          0 : }
    2990                 :            : 
    2991                 :            : static void
    2992                 :          0 : dtrace_function_return(_PyInterpreterFrame *frame)
    2993                 :            : {
    2994                 :            :     const char *filename;
    2995                 :            :     const char *funcname;
    2996                 :            :     int lineno;
    2997                 :            : 
    2998                 :          0 :     PyCodeObject *code = frame->f_code;
    2999                 :          0 :     filename = PyUnicode_AsUTF8(code->co_filename);
    3000                 :          0 :     funcname = PyUnicode_AsUTF8(code->co_name);
    3001                 :          0 :     lineno = _PyInterpreterFrame_GetLine(frame);
    3002                 :            : 
    3003                 :          0 :     PyDTrace_FUNCTION_RETURN(filename, funcname, lineno);
    3004                 :          0 : }
    3005                 :            : 
    3006                 :            : /* DTrace equivalent of maybe_call_line_trace. */
    3007                 :            : static void
    3008                 :          0 : maybe_dtrace_line(_PyInterpreterFrame *frame,
    3009                 :            :                   PyTraceInfo *trace_info,
    3010                 :            :                   int instr_prev)
    3011                 :            : {
    3012                 :            :     const char *co_filename, *co_name;
    3013                 :            : 
    3014                 :            :     /* If the last instruction executed isn't in the current
    3015                 :            :        instruction window, reset the window.
    3016                 :            :     */
    3017                 :          0 :     initialize_trace_info(trace_info, frame);
    3018                 :          0 :     int lastline = _PyCode_CheckLineNumber(instr_prev*sizeof(_Py_CODEUNIT), &trace_info->bounds);
    3019                 :          0 :     int addr = _PyInterpreterFrame_LASTI(frame) * sizeof(_Py_CODEUNIT);
    3020                 :          0 :     int line = _PyCode_CheckLineNumber(addr, &trace_info->bounds);
    3021         [ #  # ]:          0 :     if (line != -1) {
    3022                 :            :         /* Trace backward edges or first instruction of a new line */
    3023   [ #  #  #  # ]:          0 :         if (_PyInterpreterFrame_LASTI(frame) < instr_prev ||
    3024         [ #  # ]:          0 :             (line != lastline && addr == trace_info->bounds.ar_start))
    3025                 :            :         {
    3026                 :          0 :             co_filename = PyUnicode_AsUTF8(frame->f_code->co_filename);
    3027         [ #  # ]:          0 :             if (!co_filename) {
    3028                 :          0 :                 co_filename = "?";
    3029                 :            :             }
    3030                 :          0 :             co_name = PyUnicode_AsUTF8(frame->f_code->co_name);
    3031         [ #  # ]:          0 :             if (!co_name) {
    3032                 :          0 :                 co_name = "?";
    3033                 :            :             }
    3034                 :          0 :             PyDTrace_LINE(co_filename, co_name, line);
    3035                 :            :         }
    3036                 :            :     }
    3037                 :          0 : }
    3038                 :            : 
    3039                 :            : /* Implement Py_EnterRecursiveCall() and Py_LeaveRecursiveCall() as functions
    3040                 :            :    for the limited API. */
    3041                 :            : 
    3042                 :          0 : int Py_EnterRecursiveCall(const char *where)
    3043                 :            : {
    3044                 :          0 :     return _Py_EnterRecursiveCall(where);
    3045                 :            : }
    3046                 :            : 
    3047                 :          0 : void Py_LeaveRecursiveCall(void)
    3048                 :            : {
    3049                 :          0 :     _Py_LeaveRecursiveCall();
    3050                 :          0 : }

Generated by: LCOV version 1.14