LCOV - code coverage report
Current view: top level - Python - import.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 853 1537 55.5 %
Date: 2023-03-20 08:15:36 Functions: 95 125 76.0 %
Branches: 384 886 43.3 %

           Branch data     Line data    Source code
       1                 :            : /* Module definition and import implementation */
       2                 :            : 
       3                 :            : #include "Python.h"
       4                 :            : 
       5                 :            : #include "pycore_import.h"        // _PyImport_BootstrapImp()
       6                 :            : #include "pycore_initconfig.h"    // _PyStatus_OK()
       7                 :            : #include "pycore_interp.h"        // struct _import_runtime_state
       8                 :            : #include "pycore_namespace.h"     // _PyNamespace_Type
       9                 :            : #include "pycore_pyerrors.h"      // _PyErr_SetString()
      10                 :            : #include "pycore_pyhash.h"        // _Py_KeyedHash()
      11                 :            : #include "pycore_pylifecycle.h"
      12                 :            : #include "pycore_pymem.h"         // _PyMem_SetDefaultAllocator()
      13                 :            : #include "pycore_pystate.h"       // _PyInterpreterState_GET()
      14                 :            : #include "pycore_sysmodule.h"     // _PySys_Audit()
      15                 :            : #include "marshal.h"              // PyMarshal_ReadObjectFromString()
      16                 :            : #include "importdl.h"             // _PyImport_DynLoadFiletab
      17                 :            : #include "pydtrace.h"             // PyDTrace_IMPORT_FIND_LOAD_START_ENABLED()
      18                 :            : #include <stdbool.h>              // bool
      19                 :            : 
      20                 :            : #ifdef HAVE_FCNTL_H
      21                 :            : #include <fcntl.h>
      22                 :            : #endif
      23                 :            : #ifdef __cplusplus
      24                 :            : extern "C" {
      25                 :            : #endif
      26                 :            : 
      27                 :            : 
      28                 :            : /*[clinic input]
      29                 :            : module _imp
      30                 :            : [clinic start generated code]*/
      31                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=9c332475d8686284]*/
      32                 :            : 
      33                 :            : #include "clinic/import.c.h"
      34                 :            : 
      35                 :            : 
      36                 :            : /*******************************/
      37                 :            : /* process-global import state */
      38                 :            : /*******************************/
      39                 :            : 
      40                 :            : /* This table is defined in config.c: */
      41                 :            : extern struct _inittab _PyImport_Inittab[];
      42                 :            : 
      43                 :            : // This is not used after Py_Initialize() is called.
      44                 :            : // (See _PyRuntimeState.imports.inittab.)
      45                 :            : struct _inittab *PyImport_Inittab = _PyImport_Inittab;
      46                 :            : // When we dynamically allocate a larger table for PyImport_ExtendInittab(),
      47                 :            : // we track the pointer here so we can deallocate it during finalization.
      48                 :            : static struct _inittab *inittab_copy = NULL;
      49                 :            : 
      50                 :            : 
      51                 :            : /*******************************/
      52                 :            : /* runtime-global import state */
      53                 :            : /*******************************/
      54                 :            : 
      55                 :            : #define INITTAB _PyRuntime.imports.inittab
      56                 :            : #define LAST_MODULE_INDEX _PyRuntime.imports.last_module_index
      57                 :            : #define EXTENSIONS _PyRuntime.imports.extensions
      58                 :            : 
      59                 :            : #define PKGCONTEXT (_PyRuntime.imports.pkgcontext)
      60                 :            : 
      61                 :            : 
      62                 :            : /*******************************/
      63                 :            : /* interpreter import state */
      64                 :            : /*******************************/
      65                 :            : 
      66                 :            : #define MODULES(interp) \
      67                 :            :     (interp)->imports.modules
      68                 :            : #define MODULES_BY_INDEX(interp) \
      69                 :            :     (interp)->imports.modules_by_index
      70                 :            : #define IMPORTLIB(interp) \
      71                 :            :     (interp)->imports.importlib
      72                 :            : #define OVERRIDE_MULTI_INTERP_EXTENSIONS_CHECK(interp) \
      73                 :            :     (interp)->imports.override_multi_interp_extensions_check
      74                 :            : #define OVERRIDE_FROZEN_MODULES(interp) \
      75                 :            :     (interp)->imports.override_frozen_modules
      76                 :            : #ifdef HAVE_DLOPEN
      77                 :            : #  define DLOPENFLAGS(interp) \
      78                 :            :         (interp)->imports.dlopenflags
      79                 :            : #endif
      80                 :            : #define IMPORT_FUNC(interp) \
      81                 :            :     (interp)->imports.import_func
      82                 :            : 
      83                 :            : #define IMPORT_LOCK(interp) \
      84                 :            :     (interp)->imports.lock.mutex
      85                 :            : #define IMPORT_LOCK_THREAD(interp) \
      86                 :            :     (interp)->imports.lock.thread
      87                 :            : #define IMPORT_LOCK_LEVEL(interp) \
      88                 :            :     (interp)->imports.lock.level
      89                 :            : 
      90                 :            : #define FIND_AND_LOAD(interp) \
      91                 :            :     (interp)->imports.find_and_load
      92                 :            : 
      93                 :            : 
      94                 :            : /*******************/
      95                 :            : /* the import lock */
      96                 :            : /*******************/
      97                 :            : 
      98                 :            : /* Locking primitives to prevent parallel imports of the same module
      99                 :            :    in different threads to return with a partially loaded module.
     100                 :            :    These calls are serialized by the global interpreter lock. */
     101                 :            : 
     102                 :            : void
     103                 :       4609 : _PyImport_AcquireLock(PyInterpreterState *interp)
     104                 :            : {
     105                 :       4609 :     unsigned long me = PyThread_get_thread_ident();
     106         [ -  + ]:       4609 :     if (me == PYTHREAD_INVALID_THREAD_ID)
     107                 :          0 :         return; /* Too bad */
     108         [ +  + ]:       4609 :     if (IMPORT_LOCK(interp) == NULL) {
     109                 :         25 :         IMPORT_LOCK(interp) = PyThread_allocate_lock();
     110         [ -  + ]:         25 :         if (IMPORT_LOCK(interp) == NULL)
     111                 :          0 :             return;  /* Nothing much we can do. */
     112                 :            :     }
     113         [ -  + ]:       4609 :     if (IMPORT_LOCK_THREAD(interp) == me) {
     114                 :          0 :         IMPORT_LOCK_LEVEL(interp)++;
     115                 :          0 :         return;
     116                 :            :     }
     117   [ +  -  -  + ]:       9218 :     if (IMPORT_LOCK_THREAD(interp) != PYTHREAD_INVALID_THREAD_ID ||
     118                 :       4609 :         !PyThread_acquire_lock(IMPORT_LOCK(interp), 0))
     119                 :            :     {
     120                 :          0 :         PyThreadState *tstate = PyEval_SaveThread();
     121                 :          0 :         PyThread_acquire_lock(IMPORT_LOCK(interp), WAIT_LOCK);
     122                 :          0 :         PyEval_RestoreThread(tstate);
     123                 :            :     }
     124                 :            :     assert(IMPORT_LOCK_LEVEL(interp) == 0);
     125                 :       4609 :     IMPORT_LOCK_THREAD(interp) = me;
     126                 :       4609 :     IMPORT_LOCK_LEVEL(interp) = 1;
     127                 :            : }
     128                 :            : 
     129                 :            : int
     130                 :       4609 : _PyImport_ReleaseLock(PyInterpreterState *interp)
     131                 :            : {
     132                 :       4609 :     unsigned long me = PyThread_get_thread_ident();
     133   [ +  -  -  + ]:       4609 :     if (me == PYTHREAD_INVALID_THREAD_ID || IMPORT_LOCK(interp) == NULL)
     134                 :          0 :         return 0; /* Too bad */
     135         [ -  + ]:       4609 :     if (IMPORT_LOCK_THREAD(interp) != me)
     136                 :          0 :         return -1;
     137                 :       4609 :     IMPORT_LOCK_LEVEL(interp)--;
     138                 :            :     assert(IMPORT_LOCK_LEVEL(interp) >= 0);
     139         [ +  - ]:       4609 :     if (IMPORT_LOCK_LEVEL(interp) == 0) {
     140                 :       4609 :         IMPORT_LOCK_THREAD(interp) = PYTHREAD_INVALID_THREAD_ID;
     141                 :       4609 :         PyThread_release_lock(IMPORT_LOCK(interp));
     142                 :            :     }
     143                 :       4609 :     return 1;
     144                 :            : }
     145                 :            : 
     146                 :            : #ifdef HAVE_FORK
     147                 :            : /* This function is called from PyOS_AfterFork_Child() to ensure that newly
     148                 :            :    created child processes do not share locks with the parent.
     149                 :            :    We now acquire the import lock around fork() calls but on some platforms
     150                 :            :    (Solaris 9 and earlier? see isue7242) that still left us with problems. */
     151                 :            : PyStatus
     152                 :          0 : _PyImport_ReInitLock(PyInterpreterState *interp)
     153                 :            : {
     154         [ #  # ]:          0 :     if (IMPORT_LOCK(interp) != NULL) {
     155         [ #  # ]:          0 :         if (_PyThread_at_fork_reinit(&IMPORT_LOCK(interp)) < 0) {
     156                 :          0 :             return _PyStatus_ERR("failed to create a new lock");
     157                 :            :         }
     158                 :            :     }
     159                 :            : 
     160         [ #  # ]:          0 :     if (IMPORT_LOCK_LEVEL(interp) > 1) {
     161                 :            :         /* Forked as a side effect of import */
     162                 :          0 :         unsigned long me = PyThread_get_thread_ident();
     163                 :          0 :         PyThread_acquire_lock(IMPORT_LOCK(interp), WAIT_LOCK);
     164                 :          0 :         IMPORT_LOCK_THREAD(interp) = me;
     165                 :          0 :         IMPORT_LOCK_LEVEL(interp)--;
     166                 :            :     } else {
     167                 :          0 :         IMPORT_LOCK_THREAD(interp) = PYTHREAD_INVALID_THREAD_ID;
     168                 :          0 :         IMPORT_LOCK_LEVEL(interp) = 0;
     169                 :            :     }
     170                 :          0 :     return _PyStatus_OK();
     171                 :            : }
     172                 :            : #endif
     173                 :            : 
     174                 :            : 
     175                 :            : /***************/
     176                 :            : /* sys.modules */
     177                 :            : /***************/
     178                 :            : 
     179                 :            : PyObject *
     180                 :         29 : _PyImport_InitModules(PyInterpreterState *interp)
     181                 :            : {
     182                 :            :     assert(MODULES(interp) == NULL);
     183                 :         29 :     MODULES(interp) = PyDict_New();
     184         [ -  + ]:         29 :     if (MODULES(interp) == NULL) {
     185                 :          0 :         return NULL;
     186                 :            :     }
     187                 :         29 :     return MODULES(interp);
     188                 :            : }
     189                 :            : 
     190                 :            : PyObject *
     191                 :         58 : _PyImport_GetModules(PyInterpreterState *interp)
     192                 :            : {
     193                 :         58 :     return MODULES(interp);
     194                 :            : }
     195                 :            : 
     196                 :            : void
     197                 :         25 : _PyImport_ClearModules(PyInterpreterState *interp)
     198                 :            : {
     199                 :         25 :     Py_SETREF(MODULES(interp), NULL);
     200                 :         25 : }
     201                 :            : 
     202                 :            : PyObject *
     203                 :         19 : PyImport_GetModuleDict(void)
     204                 :            : {
     205                 :         19 :     PyInterpreterState *interp = _PyInterpreterState_GET();
     206         [ -  + ]:         19 :     if (MODULES(interp) == NULL) {
     207                 :          0 :         Py_FatalError("interpreter has no modules dictionary");
     208                 :            :     }
     209                 :         19 :     return MODULES(interp);
     210                 :            : }
     211                 :            : 
     212                 :            : // This is only kept around for extensions that use _Py_IDENTIFIER.
     213                 :            : PyObject *
     214                 :          0 : _PyImport_GetModuleId(_Py_Identifier *nameid)
     215                 :            : {
     216                 :          0 :     PyObject *name = _PyUnicode_FromId(nameid); /* borrowed */
     217         [ #  # ]:          0 :     if (name == NULL) {
     218                 :          0 :         return NULL;
     219                 :            :     }
     220                 :          0 :     return PyImport_GetModule(name);
     221                 :            : }
     222                 :            : 
     223                 :            : int
     224                 :          4 : _PyImport_SetModule(PyObject *name, PyObject *m)
     225                 :            : {
     226                 :          4 :     PyInterpreterState *interp = _PyInterpreterState_GET();
     227                 :          4 :     PyObject *modules = MODULES(interp);
     228                 :          4 :     return PyObject_SetItem(modules, name, m);
     229                 :            : }
     230                 :            : 
     231                 :            : int
     232                 :         25 : _PyImport_SetModuleString(const char *name, PyObject *m)
     233                 :            : {
     234                 :         25 :     PyInterpreterState *interp = _PyInterpreterState_GET();
     235                 :         25 :     PyObject *modules = MODULES(interp);
     236                 :         25 :     return PyMapping_SetItemString(modules, name, m);
     237                 :            : }
     238                 :            : 
     239                 :            : static PyObject *
     240                 :       5555 : import_get_module(PyThreadState *tstate, PyObject *name)
     241                 :            : {
     242                 :       5555 :     PyObject *modules = MODULES(tstate->interp);
     243         [ -  + ]:       5555 :     if (modules == NULL) {
     244                 :          0 :         _PyErr_SetString(tstate, PyExc_RuntimeError,
     245                 :            :                          "unable to get sys.modules");
     246                 :          0 :         return NULL;
     247                 :            :     }
     248                 :            : 
     249                 :            :     PyObject *m;
     250                 :       5555 :     Py_INCREF(modules);
     251         [ +  - ]:       5555 :     if (PyDict_CheckExact(modules)) {
     252                 :       5555 :         m = PyDict_GetItemWithError(modules, name);  /* borrowed */
     253                 :       5555 :         Py_XINCREF(m);
     254                 :            :     }
     255                 :            :     else {
     256                 :          0 :         m = PyObject_GetItem(modules, name);
     257   [ #  #  #  # ]:          0 :         if (m == NULL && _PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
     258                 :          0 :             _PyErr_Clear(tstate);
     259                 :            :         }
     260                 :            :     }
     261                 :       5555 :     Py_DECREF(modules);
     262                 :       5555 :     return m;
     263                 :            : }
     264                 :            : 
     265                 :            : static int
     266                 :       3605 : import_ensure_initialized(PyInterpreterState *interp, PyObject *mod, PyObject *name)
     267                 :            : {
     268                 :            :     PyObject *spec;
     269                 :            : 
     270                 :            :     /* Optimization: only call _bootstrap._lock_unlock_module() if
     271                 :            :        __spec__._initializing is true.
     272                 :            :        NOTE: because of this, initializing must be set *before*
     273                 :            :        stuffing the new module in sys.modules.
     274                 :            :     */
     275                 :       3605 :     spec = PyObject_GetAttr(mod, &_Py_ID(__spec__));
     276                 :       3605 :     int busy = _PyModuleSpec_IsInitializing(spec);
     277                 :       3605 :     Py_XDECREF(spec);
     278         [ +  + ]:       3605 :     if (busy) {
     279                 :            :         /* Wait until module is done importing. */
     280                 :        235 :         PyObject *value = _PyObject_CallMethodOneArg(
     281                 :            :             IMPORTLIB(interp), &_Py_ID(_lock_unlock_module), name);
     282         [ -  + ]:        235 :         if (value == NULL) {
     283                 :          0 :             return -1;
     284                 :            :         }
     285                 :        235 :         Py_DECREF(value);
     286                 :            :     }
     287                 :       3605 :     return 0;
     288                 :            : }
     289                 :            : 
     290                 :            : static void remove_importlib_frames(PyThreadState *tstate);
     291                 :            : 
     292                 :            : PyObject *
     293                 :         96 : PyImport_GetModule(PyObject *name)
     294                 :            : {
     295                 :         96 :     PyThreadState *tstate = _PyThreadState_GET();
     296                 :            :     PyObject *mod;
     297                 :            : 
     298                 :         96 :     mod = import_get_module(tstate, name);
     299   [ +  +  +  - ]:         96 :     if (mod != NULL && mod != Py_None) {
     300         [ -  + ]:         47 :         if (import_ensure_initialized(tstate->interp, mod, name) < 0) {
     301                 :          0 :             Py_DECREF(mod);
     302                 :          0 :             remove_importlib_frames(tstate);
     303                 :          0 :             return NULL;
     304                 :            :         }
     305                 :            :     }
     306                 :         96 :     return mod;
     307                 :            : }
     308                 :            : 
     309                 :            : /* Get the module object corresponding to a module name.
     310                 :            :    First check the modules dictionary if there's one there,
     311                 :            :    if not, create a new one and insert it in the modules dictionary. */
     312                 :            : 
     313                 :            : static PyObject *
     314                 :        101 : import_add_module(PyThreadState *tstate, PyObject *name)
     315                 :            : {
     316                 :        101 :     PyObject *modules = MODULES(tstate->interp);
     317         [ -  + ]:        101 :     if (modules == NULL) {
     318                 :          0 :         _PyErr_SetString(tstate, PyExc_RuntimeError,
     319                 :            :                          "no import module dictionary");
     320                 :          0 :         return NULL;
     321                 :            :     }
     322                 :            : 
     323                 :            :     PyObject *m;
     324         [ +  - ]:        101 :     if (PyDict_CheckExact(modules)) {
     325                 :        101 :         m = Py_XNewRef(PyDict_GetItemWithError(modules, name));
     326                 :            :     }
     327                 :            :     else {
     328                 :          0 :         m = PyObject_GetItem(modules, name);
     329                 :            :         // For backward-compatibility we copy the behavior
     330                 :            :         // of PyDict_GetItemWithError().
     331         [ #  # ]:          0 :         if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
     332                 :          0 :             _PyErr_Clear(tstate);
     333                 :            :         }
     334                 :            :     }
     335         [ -  + ]:        101 :     if (_PyErr_Occurred(tstate)) {
     336                 :          0 :         return NULL;
     337                 :            :     }
     338   [ +  +  +  - ]:        101 :     if (m != NULL && PyModule_Check(m)) {
     339                 :         51 :         return m;
     340                 :            :     }
     341                 :         50 :     Py_XDECREF(m);
     342                 :         50 :     m = PyModule_NewObject(name);
     343         [ -  + ]:         50 :     if (m == NULL)
     344                 :          0 :         return NULL;
     345         [ -  + ]:         50 :     if (PyObject_SetItem(modules, name, m) != 0) {
     346                 :          0 :         Py_DECREF(m);
     347                 :          0 :         return NULL;
     348                 :            :     }
     349                 :            : 
     350                 :         50 :     return m;
     351                 :            : }
     352                 :            : 
     353                 :            : PyObject *
     354                 :         73 : PyImport_AddModuleObject(PyObject *name)
     355                 :            : {
     356                 :         73 :     PyThreadState *tstate = _PyThreadState_GET();
     357                 :         73 :     PyObject *mod = import_add_module(tstate, name);
     358         [ +  - ]:         73 :     if (mod) {
     359                 :         73 :         PyObject *ref = PyWeakref_NewRef(mod, NULL);
     360                 :         73 :         Py_DECREF(mod);
     361         [ -  + ]:         73 :         if (ref == NULL) {
     362                 :          0 :             return NULL;
     363                 :            :         }
     364                 :         73 :         mod = PyWeakref_GetObject(ref);
     365                 :         73 :         Py_DECREF(ref);
     366                 :            :     }
     367                 :         73 :     return mod; /* borrowed reference */
     368                 :            : }
     369                 :            : 
     370                 :            : 
     371                 :            : PyObject *
     372                 :         73 : PyImport_AddModule(const char *name)
     373                 :            : {
     374                 :         73 :     PyObject *nameobj = PyUnicode_FromString(name);
     375         [ -  + ]:         73 :     if (nameobj == NULL) {
     376                 :          0 :         return NULL;
     377                 :            :     }
     378                 :         73 :     PyObject *module = PyImport_AddModuleObject(nameobj);
     379                 :         73 :     Py_DECREF(nameobj);
     380                 :         73 :     return module;
     381                 :            : }
     382                 :            : 
     383                 :            : 
     384                 :            : /* Remove name from sys.modules, if it's there.
     385                 :            :  * Can be called with an exception raised.
     386                 :            :  * If fail to remove name a new exception will be chained with the old
     387                 :            :  * exception, otherwise the old exception is preserved.
     388                 :            :  */
     389                 :            : static void
     390                 :          0 : remove_module(PyThreadState *tstate, PyObject *name)
     391                 :            : {
     392                 :          0 :     PyObject *exc = _PyErr_GetRaisedException(tstate);
     393                 :            : 
     394                 :          0 :     PyObject *modules = MODULES(tstate->interp);
     395         [ #  # ]:          0 :     if (PyDict_CheckExact(modules)) {
     396                 :          0 :         PyObject *mod = _PyDict_Pop(modules, name, Py_None);
     397                 :          0 :         Py_XDECREF(mod);
     398                 :            :     }
     399         [ #  # ]:          0 :     else if (PyMapping_DelItem(modules, name) < 0) {
     400         [ #  # ]:          0 :         if (_PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
     401                 :          0 :             _PyErr_Clear(tstate);
     402                 :            :         }
     403                 :            :     }
     404                 :            : 
     405                 :          0 :     _PyErr_ChainExceptions1(exc);
     406                 :          0 : }
     407                 :            : 
     408                 :            : 
     409                 :            : /************************************/
     410                 :            : /* per-interpreter modules-by-index */
     411                 :            : /************************************/
     412                 :            : 
     413                 :            : Py_ssize_t
     414                 :        481 : _PyImport_GetNextModuleIndex(void)
     415                 :            : {
     416                 :        481 :     LAST_MODULE_INDEX++;
     417                 :        481 :     return LAST_MODULE_INDEX;
     418                 :            : }
     419                 :            : 
     420                 :            : static const char *
     421                 :          1 : _modules_by_index_check(PyInterpreterState *interp, Py_ssize_t index)
     422                 :            : {
     423         [ +  - ]:          1 :     if (index == 0) {
     424                 :          1 :         return "invalid module index";
     425                 :            :     }
     426         [ #  # ]:          0 :     if (MODULES_BY_INDEX(interp) == NULL) {
     427                 :          0 :         return "Interpreters module-list not accessible.";
     428                 :            :     }
     429         [ #  # ]:          0 :     if (index > PyList_GET_SIZE(MODULES_BY_INDEX(interp))) {
     430                 :          0 :         return "Module index out of bounds.";
     431                 :            :     }
     432                 :          0 :     return NULL;
     433                 :            : }
     434                 :            : 
     435                 :            : static PyObject *
     436                 :          1 : _modules_by_index_get(PyInterpreterState *interp, PyModuleDef *def)
     437                 :            : {
     438                 :          1 :     Py_ssize_t index = def->m_base.m_index;
     439         [ +  - ]:          1 :     if (_modules_by_index_check(interp, index) != NULL) {
     440                 :          1 :         return NULL;
     441                 :            :     }
     442                 :          0 :     PyObject *res = PyList_GET_ITEM(MODULES_BY_INDEX(interp), index);
     443         [ #  # ]:          0 :     return res==Py_None ? NULL : res;
     444                 :            : }
     445                 :            : 
     446                 :            : static int
     447                 :        109 : _modules_by_index_set(PyInterpreterState *interp,
     448                 :            :                       PyModuleDef *def, PyObject *module)
     449                 :            : {
     450                 :            :     assert(def != NULL);
     451                 :            :     assert(def->m_slots == NULL);
     452                 :            :     assert(def->m_base.m_index > 0);
     453                 :            : 
     454         [ +  + ]:        109 :     if (MODULES_BY_INDEX(interp) == NULL) {
     455                 :         29 :         MODULES_BY_INDEX(interp) = PyList_New(0);
     456         [ -  + ]:         29 :         if (MODULES_BY_INDEX(interp) == NULL) {
     457                 :          0 :             return -1;
     458                 :            :         }
     459                 :            :     }
     460                 :            : 
     461                 :        109 :     Py_ssize_t index = def->m_base.m_index;
     462         [ +  + ]:        453 :     while (PyList_GET_SIZE(MODULES_BY_INDEX(interp)) <= index) {
     463         [ -  + ]:        344 :         if (PyList_Append(MODULES_BY_INDEX(interp), Py_None) < 0) {
     464                 :          0 :             return -1;
     465                 :            :         }
     466                 :            :     }
     467                 :            : 
     468                 :        109 :     return PyList_SetItem(MODULES_BY_INDEX(interp), index, Py_NewRef(module));
     469                 :            : }
     470                 :            : 
     471                 :            : static int
     472                 :          0 : _modules_by_index_clear_one(PyInterpreterState *interp, PyModuleDef *def)
     473                 :            : {
     474                 :          0 :     Py_ssize_t index = def->m_base.m_index;
     475                 :          0 :     const char *err = _modules_by_index_check(interp, index);
     476         [ #  # ]:          0 :     if (err != NULL) {
     477                 :          0 :         Py_FatalError(err);
     478                 :            :         return -1;
     479                 :            :     }
     480                 :          0 :     return PyList_SetItem(MODULES_BY_INDEX(interp), index, Py_NewRef(Py_None));
     481                 :            : }
     482                 :            : 
     483                 :            : 
     484                 :            : PyObject*
     485                 :          1 : PyState_FindModule(PyModuleDef* module)
     486                 :            : {
     487                 :          1 :     PyInterpreterState *interp = _PyInterpreterState_GET();
     488         [ -  + ]:          1 :     if (module->m_slots) {
     489                 :          0 :         return NULL;
     490                 :            :     }
     491                 :          1 :     return _modules_by_index_get(interp, module);
     492                 :            : }
     493                 :            : 
     494                 :            : /* _PyState_AddModule() has been completely removed from the C-API
     495                 :            :    (and was removed from the limited API in 3.6).  However, we're
     496                 :            :    playing it safe and keeping it around for any stable ABI extensions
     497                 :            :    built against 3.2-3.5. */
     498                 :            : int
     499                 :          0 : _PyState_AddModule(PyThreadState *tstate, PyObject* module, PyModuleDef* def)
     500                 :            : {
     501         [ #  # ]:          0 :     if (!def) {
     502                 :            :         assert(_PyErr_Occurred(tstate));
     503                 :          0 :         return -1;
     504                 :            :     }
     505         [ #  # ]:          0 :     if (def->m_slots) {
     506                 :          0 :         _PyErr_SetString(tstate,
     507                 :            :                          PyExc_SystemError,
     508                 :            :                          "PyState_AddModule called on module with slots");
     509                 :          0 :         return -1;
     510                 :            :     }
     511                 :          0 :     return _modules_by_index_set(tstate->interp, def, module);
     512                 :            : }
     513                 :            : 
     514                 :            : int
     515                 :          2 : PyState_AddModule(PyObject* module, PyModuleDef* def)
     516                 :            : {
     517         [ -  + ]:          2 :     if (!def) {
     518                 :          0 :         Py_FatalError("module definition is NULL");
     519                 :            :         return -1;
     520                 :            :     }
     521                 :            : 
     522                 :          2 :     PyThreadState *tstate = _PyThreadState_GET();
     523         [ -  + ]:          2 :     if (def->m_slots) {
     524                 :          0 :         _PyErr_SetString(tstate,
     525                 :            :                          PyExc_SystemError,
     526                 :            :                          "PyState_AddModule called on module with slots");
     527                 :          0 :         return -1;
     528                 :            :     }
     529                 :            : 
     530                 :          2 :     PyInterpreterState *interp = tstate->interp;
     531                 :          2 :     Py_ssize_t index = def->m_base.m_index;
     532   [ +  -  -  + ]:          4 :     if (MODULES_BY_INDEX(interp) &&
     533                 :          2 :         index < PyList_GET_SIZE(MODULES_BY_INDEX(interp)) &&
     534         [ #  # ]:          0 :         module == PyList_GET_ITEM(MODULES_BY_INDEX(interp), index))
     535                 :            :     {
     536                 :          0 :         _Py_FatalErrorFormat(__func__, "module %p already added", module);
     537                 :            :         return -1;
     538                 :            :     }
     539                 :            : 
     540                 :          2 :     return _modules_by_index_set(interp, def, module);
     541                 :            : }
     542                 :            : 
     543                 :            : int
     544                 :          0 : PyState_RemoveModule(PyModuleDef* def)
     545                 :            : {
     546                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
     547         [ #  # ]:          0 :     if (def->m_slots) {
     548                 :          0 :         _PyErr_SetString(tstate,
     549                 :            :                          PyExc_SystemError,
     550                 :            :                          "PyState_RemoveModule called on module with slots");
     551                 :          0 :         return -1;
     552                 :            :     }
     553                 :          0 :     return _modules_by_index_clear_one(tstate->interp, def);
     554                 :            : }
     555                 :            : 
     556                 :            : 
     557                 :            : // Used by finalize_modules()
     558                 :            : void
     559                 :         25 : _PyImport_ClearModulesByIndex(PyInterpreterState *interp)
     560                 :            : {
     561         [ -  + ]:         25 :     if (!MODULES_BY_INDEX(interp)) {
     562                 :          0 :         return;
     563                 :            :     }
     564                 :            : 
     565                 :            :     Py_ssize_t i;
     566         [ +  + ]:        357 :     for (i = 0; i < PyList_GET_SIZE(MODULES_BY_INDEX(interp)); i++) {
     567                 :        332 :         PyObject *m = PyList_GET_ITEM(MODULES_BY_INDEX(interp), i);
     568         [ +  + ]:        332 :         if (PyModule_Check(m)) {
     569                 :            :             /* cleanup the saved copy of module dicts */
     570                 :         95 :             PyModuleDef *md = PyModule_GetDef(m);
     571         [ +  - ]:         95 :             if (md) {
     572         [ +  + ]:         95 :                 Py_CLEAR(md->m_base.m_copy);
     573                 :            :             }
     574                 :            :         }
     575                 :            :     }
     576                 :            : 
     577                 :            :     /* Setting modules_by_index to NULL could be dangerous, so we
     578                 :            :        clear the list instead. */
     579         [ -  + ]:         25 :     if (PyList_SetSlice(MODULES_BY_INDEX(interp),
     580                 :            :                         0, PyList_GET_SIZE(MODULES_BY_INDEX(interp)),
     581                 :            :                         NULL)) {
     582                 :          0 :         PyErr_WriteUnraisable(MODULES_BY_INDEX(interp));
     583                 :            :     }
     584                 :            : }
     585                 :            : 
     586                 :            : 
     587                 :            : /*********************/
     588                 :            : /* extension modules */
     589                 :            : /*********************/
     590                 :            : 
     591                 :            : /*
     592                 :            :     It may help to have a big picture view of what happens
     593                 :            :     when an extension is loaded.  This includes when it is imported
     594                 :            :     for the first time or via imp.load_dynamic().
     595                 :            : 
     596                 :            :     Here's a summary, using imp.load_dynamic() as the starting point:
     597                 :            : 
     598                 :            :     1.  imp.load_dynamic() -> importlib._bootstrap._load()
     599                 :            :     2.    _load():  acquire import lock
     600                 :            :     3.    _load() -> importlib._bootstrap._load_unlocked()
     601                 :            :     4.      _load_unlocked() -> importlib._bootstrap.module_from_spec()
     602                 :            :     5.        module_from_spec() -> ExtensionFileLoader.create_module()
     603                 :            :     6.          create_module() -> _imp.create_dynamic()
     604                 :            :                     (see below)
     605                 :            :     7.        module_from_spec() -> importlib._bootstrap._init_module_attrs()
     606                 :            :     8.      _load_unlocked():  sys.modules[name] = module
     607                 :            :     9.      _load_unlocked() -> ExtensionFileLoader.exec_module()
     608                 :            :     10.       exec_module() -> _imp.exec_dynamic()
     609                 :            :                   (see below)
     610                 :            :     11.   _load():  release import lock
     611                 :            : 
     612                 :            : 
     613                 :            :     ...for single-phase init modules, where m_size == -1:
     614                 :            : 
     615                 :            :     (6). first time  (not found in _PyRuntime.imports.extensions):
     616                 :            :        1.  _imp_create_dynamic_impl() -> import_find_extension()
     617                 :            :        2.  _imp_create_dynamic_impl() -> _PyImport_LoadDynamicModuleWithSpec()
     618                 :            :        3.    _PyImport_LoadDynamicModuleWithSpec():  load <module init func>
     619                 :            :        4.    _PyImport_LoadDynamicModuleWithSpec():  call <module init func>
     620                 :            :        5.      <module init func> -> PyModule_Create() -> PyModule_Create2() -> PyModule_CreateInitialized()
     621                 :            :        6.        PyModule_CreateInitialized() -> PyModule_New()
     622                 :            :        7.        PyModule_CreateInitialized():  allocate mod->md_state
     623                 :            :        8.        PyModule_CreateInitialized() -> PyModule_AddFunctions()
     624                 :            :        9.        PyModule_CreateInitialized() -> PyModule_SetDocString()
     625                 :            :        10.       PyModule_CreateInitialized():  set mod->md_def
     626                 :            :        11.     <module init func>:  initialize the module
     627                 :            :        12.   _PyImport_LoadDynamicModuleWithSpec() -> _PyImport_CheckSubinterpIncompatibleExtensionAllowed()
     628                 :            :        13.   _PyImport_LoadDynamicModuleWithSpec():  set def->m_base.m_init
     629                 :            :        14.   _PyImport_LoadDynamicModuleWithSpec():  set __file__
     630                 :            :        15.   _PyImport_LoadDynamicModuleWithSpec() -> _PyImport_FixupExtensionObject()
     631                 :            :        16.     _PyImport_FixupExtensionObject():  add it to interp->imports.modules_by_index
     632                 :            :        17.     _PyImport_FixupExtensionObject():  copy __dict__ into def->m_base.m_copy
     633                 :            :        18.     _PyImport_FixupExtensionObject():  add it to _PyRuntime.imports.extensions
     634                 :            : 
     635                 :            :     (6). subsequent times  (found in _PyRuntime.imports.extensions):
     636                 :            :        1. _imp_create_dynamic_impl() -> import_find_extension()
     637                 :            :        2.   import_find_extension() -> import_add_module()
     638                 :            :        3.     if name in sys.modules:  use that module
     639                 :            :        4.     else:
     640                 :            :                 1. import_add_module() -> PyModule_NewObject()
     641                 :            :                 2. import_add_module():  set it on sys.modules
     642                 :            :        5.   import_find_extension():  copy the "m_copy" dict into __dict__
     643                 :            :        6. _imp_create_dynamic_impl() -> _PyImport_CheckSubinterpIncompatibleExtensionAllowed()
     644                 :            : 
     645                 :            :     (10). (every time):
     646                 :            :        1. noop
     647                 :            : 
     648                 :            : 
     649                 :            :     ...for single-phase init modules, where m_size >= 0:
     650                 :            : 
     651                 :            :     (6). not main interpreter and never loaded there - every time  (not found in _PyRuntime.imports.extensions):
     652                 :            :        1-16. (same as for m_size == -1)
     653                 :            : 
     654                 :            :     (6). main interpreter - first time  (not found in _PyRuntime.imports.extensions):
     655                 :            :        1-16. (same as for m_size == -1)
     656                 :            :        17.     _PyImport_FixupExtensionObject():  add it to _PyRuntime.imports.extensions
     657                 :            : 
     658                 :            :     (6). previously loaded in main interpreter  (found in _PyRuntime.imports.extensions):
     659                 :            :        1. _imp_create_dynamic_impl() -> import_find_extension()
     660                 :            :        2.   import_find_extension():  call def->m_base.m_init
     661                 :            :        3.   import_find_extension():  add the module to sys.modules
     662                 :            : 
     663                 :            :     (10). every time:
     664                 :            :        1. noop
     665                 :            : 
     666                 :            : 
     667                 :            :     ...for multi-phase init modules:
     668                 :            : 
     669                 :            :     (6). every time:
     670                 :            :        1.  _imp_create_dynamic_impl() -> import_find_extension()  (not found)
     671                 :            :        2.  _imp_create_dynamic_impl() -> _PyImport_LoadDynamicModuleWithSpec()
     672                 :            :        3.    _PyImport_LoadDynamicModuleWithSpec():  load module init func
     673                 :            :        4.    _PyImport_LoadDynamicModuleWithSpec():  call module init func
     674                 :            :        5.    _PyImport_LoadDynamicModuleWithSpec() -> PyModule_FromDefAndSpec()
     675                 :            :        6.      PyModule_FromDefAndSpec(): gather/check moduledef slots
     676                 :            :        7.      if there's a Py_mod_create slot:
     677                 :            :                  1. PyModule_FromDefAndSpec():  call its function
     678                 :            :        8.      else:
     679                 :            :                  1. PyModule_FromDefAndSpec() -> PyModule_NewObject()
     680                 :            :        9:      PyModule_FromDefAndSpec():  set mod->md_def
     681                 :            :        10.     PyModule_FromDefAndSpec() -> _add_methods_to_object()
     682                 :            :        11.     PyModule_FromDefAndSpec() -> PyModule_SetDocString()
     683                 :            : 
     684                 :            :     (10). every time:
     685                 :            :        1. _imp_exec_dynamic_impl() -> exec_builtin_or_dynamic()
     686                 :            :        2.   if mod->md_state == NULL (including if m_size == 0):
     687                 :            :             1. exec_builtin_or_dynamic() -> PyModule_ExecDef()
     688                 :            :             2.   PyModule_ExecDef():  allocate mod->md_state
     689                 :            :             3.   if there's a Py_mod_exec slot:
     690                 :            :                  1. PyModule_ExecDef():  call its function
     691                 :            :  */
     692                 :            : 
     693                 :            : 
     694                 :            : /* Make sure name is fully qualified.
     695                 :            : 
     696                 :            :    This is a bit of a hack: when the shared library is loaded,
     697                 :            :    the module name is "package.module", but the module calls
     698                 :            :    PyModule_Create*() with just "module" for the name.  The shared
     699                 :            :    library loader squirrels away the true name of the module in
     700                 :            :    _PyRuntime.imports.pkgcontext, and PyModule_Create*() will
     701                 :            :    substitute this (if the name actually matches).
     702                 :            : */
     703                 :            : const char *
     704                 :        104 : _PyImport_ResolveNameWithPackageContext(const char *name)
     705                 :            : {
     706         [ +  + ]:        104 :     if (PKGCONTEXT != NULL) {
     707                 :         19 :         const char *p = strrchr(PKGCONTEXT, '.');
     708   [ -  +  -  - ]:         19 :         if (p != NULL && strcmp(name, p+1) == 0) {
     709                 :          0 :             name = PKGCONTEXT;
     710                 :          0 :             PKGCONTEXT = NULL;
     711                 :            :         }
     712                 :            :     }
     713                 :        104 :     return name;
     714                 :            : }
     715                 :            : 
     716                 :            : const char *
     717                 :        228 : _PyImport_SwapPackageContext(const char *newcontext)
     718                 :            : {
     719                 :        228 :     const char *oldcontext = PKGCONTEXT;
     720                 :        228 :     PKGCONTEXT = newcontext;
     721                 :        228 :     return oldcontext;
     722                 :            : }
     723                 :            : 
     724                 :            : #ifdef HAVE_DLOPEN
     725                 :            : int
     726                 :        114 : _PyImport_GetDLOpenFlags(PyInterpreterState *interp)
     727                 :            : {
     728                 :        114 :     return DLOPENFLAGS(interp);
     729                 :            : }
     730                 :            : 
     731                 :            : void
     732                 :          0 : _PyImport_SetDLOpenFlags(PyInterpreterState *interp, int new_val)
     733                 :            : {
     734                 :          0 :     DLOPENFLAGS(interp) = new_val;
     735                 :          0 : }
     736                 :            : #endif  // HAVE_DLOPEN
     737                 :            : 
     738                 :            : 
     739                 :            : /* Common implementation for _imp.exec_dynamic and _imp.exec_builtin */
     740                 :            : static int
     741                 :        463 : exec_builtin_or_dynamic(PyObject *mod) {
     742                 :            :     PyModuleDef *def;
     743                 :            :     void *state;
     744                 :            : 
     745         [ -  + ]:        463 :     if (!PyModule_Check(mod)) {
     746                 :          0 :         return 0;
     747                 :            :     }
     748                 :            : 
     749                 :        463 :     def = PyModule_GetDef(mod);
     750         [ -  + ]:        463 :     if (def == NULL) {
     751                 :          0 :         return 0;
     752                 :            :     }
     753                 :            : 
     754                 :        463 :     state = PyModule_GetState(mod);
     755         [ +  + ]:        463 :     if (state) {
     756                 :            :         /* Already initialized; skip reload */
     757                 :         29 :         return 0;
     758                 :            :     }
     759                 :            : 
     760                 :        434 :     return PyModule_ExecDef(mod, def);
     761                 :            : }
     762                 :            : 
     763                 :            : 
     764                 :            : static int clear_singlephase_extension(PyInterpreterState *interp,
     765                 :            :                                        PyObject *name, PyObject *filename);
     766                 :            : 
     767                 :            : // Currently, this is only used for testing.
     768                 :            : // (See _testinternalcapi.clear_extension().)
     769                 :            : int
     770                 :          0 : _PyImport_ClearExtension(PyObject *name, PyObject *filename)
     771                 :            : {
     772                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
     773                 :            : 
     774                 :            :     /* Clearing a module's C globals is up to the module. */
     775         [ #  # ]:          0 :     if (clear_singlephase_extension(interp, name, filename) < 0) {
     776                 :          0 :         return -1;
     777                 :            :     }
     778                 :            : 
     779                 :            :     // In the future we'll probably also make sure the extension's
     780                 :            :     // file handle (and DL handle) is closed (requires saving it).
     781                 :            : 
     782                 :          0 :     return 0;
     783                 :            : }
     784                 :            : 
     785                 :            : 
     786                 :            : /*******************/
     787                 :            : 
     788                 :            : #if defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE)
     789                 :            : #include <emscripten.h>
     790                 :            : EM_JS(PyObject*, _PyImport_InitFunc_TrampolineCall, (PyModInitFunction func), {
     791                 :            :     return wasmTable.get(func)();
     792                 :            : });
     793                 :            : #endif // __EMSCRIPTEN__ && PY_CALL_TRAMPOLINE
     794                 :            : 
     795                 :            : 
     796                 :            : /*****************************/
     797                 :            : /* single-phase init modules */
     798                 :            : /*****************************/
     799                 :            : 
     800                 :            : /*
     801                 :            : We support a number of kinds of single-phase init builtin/extension modules:
     802                 :            : 
     803                 :            : * "basic"
     804                 :            :     * no module state (PyModuleDef.m_size == -1)
     805                 :            :     * does not support repeated init (we use PyModuleDef.m_base.m_copy)
     806                 :            :     * may have process-global state
     807                 :            :     * the module's def is cached in _PyRuntime.imports.extensions,
     808                 :            :       by (name, filename)
     809                 :            : * "reinit"
     810                 :            :     * no module state (PyModuleDef.m_size == 0)
     811                 :            :     * supports repeated init (m_copy is never used)
     812                 :            :     * should not have any process-global state
     813                 :            :     * its def is never cached in _PyRuntime.imports.extensions
     814                 :            :       (except, currently, under the main interpreter, for some reason)
     815                 :            : * "with state"  (almost the same as reinit)
     816                 :            :     * has module state (PyModuleDef.m_size > 0)
     817                 :            :     * supports repeated init (m_copy is never used)
     818                 :            :     * should not have any process-global state
     819                 :            :     * its def is never cached in _PyRuntime.imports.extensions
     820                 :            :       (except, currently, under the main interpreter, for some reason)
     821                 :            : 
     822                 :            : There are also variants within those classes:
     823                 :            : 
     824                 :            : * two or more modules share a PyModuleDef
     825                 :            :     * a module's init func uses another module's PyModuleDef
     826                 :            :     * a module's init func calls another's module's init func
     827                 :            :     * a module's init "func" is actually a variable statically initialized
     828                 :            :       to another module's init func
     829                 :            : * two or modules share "methods"
     830                 :            :     * a module's init func copies another module's PyModuleDef
     831                 :            :       (with a different name)
     832                 :            : * (basic-only) two or modules share process-global state
     833                 :            : 
     834                 :            : In the first case, where modules share a PyModuleDef, the following
     835                 :            : notable weirdness happens:
     836                 :            : 
     837                 :            : * the module's __name__ matches the def, not the requested name
     838                 :            : * the last module (with the same def) to be imported for the first time wins
     839                 :            :     * returned by PyState_Find_Module() (via interp->modules_by_index)
     840                 :            :     * (non-basic-only) its init func is used when re-loading any of them
     841                 :            :       (via the def's m_init)
     842                 :            :     * (basic-only) the copy of its __dict__ is used when re-loading any of them
     843                 :            :       (via the def's m_copy)
     844                 :            : 
     845                 :            : However, the following happens as expected:
     846                 :            : 
     847                 :            : * a new module object (with its own __dict__) is created for each request
     848                 :            : * the module's __spec__ has the requested name
     849                 :            : * the loaded module is cached in sys.modules under the requested name
     850                 :            : * the m_index field of the shared def is not changed,
     851                 :            :   so at least PyState_FindModule() will always look in the same place
     852                 :            : 
     853                 :            : For "basic" modules there are other quirks:
     854                 :            : 
     855                 :            : * (whether sharing a def or not) when loaded the first time,
     856                 :            :   m_copy is set before _init_module_attrs() is called
     857                 :            :   in importlib._bootstrap.module_from_spec(),
     858                 :            :   so when the module is re-loaded, the previous value
     859                 :            :   for __wpec__ (and others) is reset, possibly unexpectedly.
     860                 :            : 
     861                 :            : Generally, when multiple interpreters are involved, some of the above
     862                 :            : gets even messier.
     863                 :            : */
     864                 :            : 
     865                 :            : /* Magic for extension modules (built-in as well as dynamically
     866                 :            :    loaded).  To prevent initializing an extension module more than
     867                 :            :    once, we keep a static dictionary 'extensions' keyed by the tuple
     868                 :            :    (module name, module name)  (for built-in modules) or by
     869                 :            :    (filename, module name) (for dynamically loaded modules), containing these
     870                 :            :    modules.  A copy of the module's dictionary is stored by calling
     871                 :            :    _PyImport_FixupExtensionObject() immediately after the module initialization
     872                 :            :    function succeeds.  A copy can be retrieved from there by calling
     873                 :            :    import_find_extension().
     874                 :            : 
     875                 :            :    Modules which do support multiple initialization set their m_size
     876                 :            :    field to a non-negative number (indicating the size of the
     877                 :            :    module-specific state). They are still recorded in the extensions
     878                 :            :    dictionary, to avoid loading shared libraries twice.
     879                 :            : */
     880                 :            : 
     881                 :            : static PyModuleDef *
     882                 :        463 : _extensions_cache_get(PyObject *filename, PyObject *name)
     883                 :            : {
     884                 :        463 :     PyObject *extensions = EXTENSIONS;
     885         [ -  + ]:        463 :     if (extensions == NULL) {
     886                 :          0 :         return NULL;
     887                 :            :     }
     888                 :        463 :     PyObject *key = PyTuple_Pack(2, filename, name);
     889         [ -  + ]:        463 :     if (key == NULL) {
     890                 :          0 :         return NULL;
     891                 :            :     }
     892                 :        463 :     PyModuleDef *def = (PyModuleDef *)PyDict_GetItemWithError(extensions, key);
     893                 :        463 :     Py_DECREF(key);
     894                 :        463 :     return def;
     895                 :            : }
     896                 :            : 
     897                 :            : static int
     898                 :        103 : _extensions_cache_set(PyObject *filename, PyObject *name, PyModuleDef *def)
     899                 :            : {
     900                 :        103 :     PyObject *extensions = EXTENSIONS;
     901         [ +  + ]:        103 :     if (extensions == NULL) {
     902                 :         29 :         extensions = PyDict_New();
     903         [ -  + ]:         29 :         if (extensions == NULL) {
     904                 :          0 :             return -1;
     905                 :            :         }
     906                 :         29 :         EXTENSIONS = extensions;
     907                 :            :     }
     908                 :        103 :     PyObject *key = PyTuple_Pack(2, filename, name);
     909         [ -  + ]:        103 :     if (key == NULL) {
     910                 :          0 :         return -1;
     911                 :            :     }
     912                 :        103 :     int res = PyDict_SetItem(extensions, key, (PyObject *)def);
     913                 :        103 :     Py_DECREF(key);
     914         [ -  + ]:        103 :     if (res < 0) {
     915                 :          0 :         return -1;
     916                 :            :     }
     917                 :        103 :     return 0;
     918                 :            : }
     919                 :            : 
     920                 :            : static int
     921                 :          0 : _extensions_cache_delete(PyObject *filename, PyObject *name)
     922                 :            : {
     923                 :          0 :     PyObject *extensions = EXTENSIONS;
     924         [ #  # ]:          0 :     if (extensions == NULL) {
     925                 :          0 :         return 0;
     926                 :            :     }
     927                 :          0 :     PyObject *key = PyTuple_Pack(2, filename, name);
     928         [ #  # ]:          0 :     if (key == NULL) {
     929                 :          0 :         return -1;
     930                 :            :     }
     931         [ #  # ]:          0 :     if (PyDict_DelItem(extensions, key) < 0) {
     932         [ #  # ]:          0 :         if (!PyErr_ExceptionMatches(PyExc_KeyError)) {
     933                 :          0 :             Py_DECREF(key);
     934                 :          0 :             return -1;
     935                 :            :         }
     936                 :          0 :         PyErr_Clear();
     937                 :            :     }
     938                 :          0 :     Py_DECREF(key);
     939                 :          0 :     return 0;
     940                 :            : }
     941                 :            : 
     942                 :            : static void
     943                 :         25 : _extensions_cache_clear_all(void)
     944                 :            : {
     945         [ +  - ]:         25 :     Py_CLEAR(EXTENSIONS);
     946                 :         25 : }
     947                 :            : 
     948                 :            : 
     949                 :            : static bool
     950                 :         20 : check_multi_interp_extensions(PyInterpreterState *interp)
     951                 :            : {
     952                 :         20 :     int override = OVERRIDE_MULTI_INTERP_EXTENSIONS_CHECK(interp);
     953         [ -  + ]:         20 :     if (override < 0) {
     954                 :          0 :         return false;
     955                 :            :     }
     956         [ -  + ]:         20 :     else if (override > 0) {
     957                 :          0 :         return true;
     958                 :            :     }
     959         [ -  + ]:         20 :     else if (_PyInterpreterState_HasFeature(
     960                 :            :                 interp, Py_RTFLAGS_MULTI_INTERP_EXTENSIONS)) {
     961                 :          0 :         return true;
     962                 :            :     }
     963                 :         20 :     return false;
     964                 :            : }
     965                 :            : 
     966                 :            : int
     967                 :         20 : _PyImport_CheckSubinterpIncompatibleExtensionAllowed(const char *name)
     968                 :            : {
     969                 :         20 :     PyInterpreterState *interp = _PyInterpreterState_Get();
     970         [ -  + ]:         20 :     if (check_multi_interp_extensions(interp)) {
     971                 :            :         assert(!_Py_IsMainInterpreter(interp));
     972                 :          0 :         PyErr_Format(PyExc_ImportError,
     973                 :            :                      "module %s does not support loading in subinterpreters",
     974                 :            :                      name);
     975                 :          0 :         return -1;
     976                 :            :     }
     977                 :         20 :     return 0;
     978                 :            : }
     979                 :            : 
     980                 :            : static PyObject *
     981                 :         73 : get_core_module_dict(PyInterpreterState *interp,
     982                 :            :                      PyObject *name, PyObject *filename)
     983                 :            : {
     984                 :            :     /* Only builtin modules are core. */
     985         [ +  + ]:         73 :     if (filename == name) {
     986                 :            :         assert(!PyErr_Occurred());
     987         [ +  + ]:         59 :         if (PyUnicode_CompareWithASCIIString(name, "sys") == 0) {
     988                 :         30 :             return interp->sysdict_copy;
     989                 :            :         }
     990                 :            :         assert(!PyErr_Occurred());
     991         [ +  - ]:         29 :         if (PyUnicode_CompareWithASCIIString(name, "builtins") == 0) {
     992                 :         29 :             return interp->builtins_copy;
     993                 :            :         }
     994                 :            :         assert(!PyErr_Occurred());
     995                 :            :     }
     996                 :         14 :     return NULL;
     997                 :            : }
     998                 :            : 
     999                 :            : static inline int
    1000                 :         72 : is_core_module(PyInterpreterState *interp, PyObject *name, PyObject *filename)
    1001                 :            : {
    1002                 :         72 :     return get_core_module_dict(interp, name, filename) != NULL;
    1003                 :            : }
    1004                 :            : 
    1005                 :            : static int
    1006                 :        103 : fix_up_extension(PyObject *mod, PyObject *name, PyObject *filename)
    1007                 :            : {
    1008   [ +  -  -  + ]:        103 :     if (mod == NULL || !PyModule_Check(mod)) {
    1009                 :          0 :         PyErr_BadInternalCall();
    1010                 :          0 :         return -1;
    1011                 :            :     }
    1012                 :            : 
    1013                 :        103 :     struct PyModuleDef *def = PyModule_GetDef(mod);
    1014         [ -  + ]:        103 :     if (!def) {
    1015                 :          0 :         PyErr_BadInternalCall();
    1016                 :          0 :         return -1;
    1017                 :            :     }
    1018                 :            : 
    1019                 :        103 :     PyThreadState *tstate = _PyThreadState_GET();
    1020         [ -  + ]:        103 :     if (_modules_by_index_set(tstate->interp, def, mod) < 0) {
    1021                 :          0 :         return -1;
    1022                 :            :     }
    1023                 :            : 
    1024                 :            :     // bpo-44050: Extensions and def->m_base.m_copy can be updated
    1025                 :            :     // when the extension module doesn't support sub-interpreters.
    1026         [ +  + ]:        103 :     if (def->m_size == -1) {
    1027         [ +  + ]:         72 :         if (!is_core_module(tstate->interp, name, filename)) {
    1028         [ -  + ]:         43 :             if (def->m_base.m_copy) {
    1029                 :            :                 /* Somebody already imported the module,
    1030                 :            :                    likely under a different name.
    1031                 :            :                    XXX this should really not happen. */
    1032         [ #  # ]:          0 :                 Py_CLEAR(def->m_base.m_copy);
    1033                 :            :             }
    1034                 :         43 :             PyObject *dict = PyModule_GetDict(mod);
    1035         [ -  + ]:         43 :             if (dict == NULL) {
    1036                 :          0 :                 return -1;
    1037                 :            :             }
    1038                 :         43 :             def->m_base.m_copy = PyDict_Copy(dict);
    1039         [ -  + ]:         43 :             if (def->m_base.m_copy == NULL) {
    1040                 :          0 :                 return -1;
    1041                 :            :             }
    1042                 :            :         }
    1043                 :            :     }
    1044                 :            : 
    1045                 :            :     // XXX Why special-case the main interpreter?
    1046   [ -  +  -  - ]:        103 :     if (_Py_IsMainInterpreter(tstate->interp) || def->m_size == -1) {
    1047         [ -  + ]:        103 :         if (_extensions_cache_set(filename, name, def) < 0) {
    1048                 :          0 :             return -1;
    1049                 :            :         }
    1050                 :            :     }
    1051                 :            : 
    1052                 :        103 :     return 0;
    1053                 :            : }
    1054                 :            : 
    1055                 :            : int
    1056                 :         45 : _PyImport_FixupExtensionObject(PyObject *mod, PyObject *name,
    1057                 :            :                                PyObject *filename, PyObject *modules)
    1058                 :            : {
    1059         [ -  + ]:         45 :     if (PyObject_SetItem(modules, name, mod) < 0) {
    1060                 :          0 :         return -1;
    1061                 :            :     }
    1062         [ -  + ]:         45 :     if (fix_up_extension(mod, name, filename) < 0) {
    1063                 :          0 :         PyMapping_DelItem(modules, name);
    1064                 :          0 :         return -1;
    1065                 :            :     }
    1066                 :         45 :     return 0;
    1067                 :            : }
    1068                 :            : 
    1069                 :            : 
    1070                 :            : static PyObject *
    1071                 :        463 : import_find_extension(PyThreadState *tstate, PyObject *name,
    1072                 :            :                       PyObject *filename)
    1073                 :            : {
    1074                 :            :     /* Only single-phase init modules will be in the cache. */
    1075                 :        463 :     PyModuleDef *def = _extensions_cache_get(filename, name);
    1076         [ +  + ]:        463 :     if (def == NULL) {
    1077                 :        459 :         return NULL;
    1078                 :            :     }
    1079                 :            : 
    1080                 :            :     PyObject *mod, *mdict;
    1081                 :          4 :     PyObject *modules = MODULES(tstate->interp);
    1082                 :            : 
    1083         [ +  + ]:          4 :     if (def->m_size == -1) {
    1084                 :          3 :         PyObject *m_copy = def->m_base.m_copy;
    1085                 :            :         /* Module does not support repeated initialization */
    1086         [ +  + ]:          3 :         if (m_copy == NULL) {
    1087                 :          1 :             m_copy = get_core_module_dict(tstate->interp, name, filename);
    1088         [ -  + ]:          1 :             if (m_copy == NULL) {
    1089                 :          0 :                 return NULL;
    1090                 :            :             }
    1091                 :            :         }
    1092                 :          3 :         mod = import_add_module(tstate, name);
    1093         [ -  + ]:          3 :         if (mod == NULL) {
    1094                 :          0 :             return NULL;
    1095                 :            :         }
    1096                 :          3 :         mdict = PyModule_GetDict(mod);
    1097         [ -  + ]:          3 :         if (mdict == NULL) {
    1098                 :          0 :             Py_DECREF(mod);
    1099                 :          0 :             return NULL;
    1100                 :            :         }
    1101         [ -  + ]:          3 :         if (PyDict_Update(mdict, m_copy)) {
    1102                 :          0 :             Py_DECREF(mod);
    1103                 :          0 :             return NULL;
    1104                 :            :         }
    1105                 :            :     }
    1106                 :            :     else {
    1107         [ -  + ]:          1 :         if (def->m_base.m_init == NULL)
    1108                 :          0 :             return NULL;
    1109                 :          1 :         mod = _PyImport_InitFunc_TrampolineCall(def->m_base.m_init);
    1110         [ -  + ]:          1 :         if (mod == NULL)
    1111                 :          0 :             return NULL;
    1112         [ -  + ]:          1 :         if (PyObject_SetItem(modules, name, mod) == -1) {
    1113                 :          0 :             Py_DECREF(mod);
    1114                 :          0 :             return NULL;
    1115                 :            :         }
    1116                 :            :     }
    1117         [ -  + ]:          4 :     if (_modules_by_index_set(tstate->interp, def, mod) < 0) {
    1118                 :          0 :         PyMapping_DelItem(modules, name);
    1119                 :          0 :         Py_DECREF(mod);
    1120                 :          0 :         return NULL;
    1121                 :            :     }
    1122                 :            : 
    1123                 :          4 :     int verbose = _PyInterpreterState_GetConfig(tstate->interp)->verbose;
    1124         [ -  + ]:          4 :     if (verbose) {
    1125                 :          0 :         PySys_FormatStderr("import %U # previously loaded (%R)\n",
    1126                 :            :                            name, filename);
    1127                 :            :     }
    1128                 :          4 :     return mod;
    1129                 :            : }
    1130                 :            : 
    1131                 :            : static int
    1132                 :          0 : clear_singlephase_extension(PyInterpreterState *interp,
    1133                 :            :                             PyObject *name, PyObject *filename)
    1134                 :            : {
    1135                 :          0 :     PyModuleDef *def = _extensions_cache_get(filename, name);
    1136         [ #  # ]:          0 :     if (def == NULL) {
    1137         [ #  # ]:          0 :         if (PyErr_Occurred()) {
    1138                 :          0 :             return -1;
    1139                 :            :         }
    1140                 :          0 :         return 0;
    1141                 :            :     }
    1142                 :            : 
    1143                 :            :     /* Clear data set when the module was initially loaded. */
    1144                 :          0 :     def->m_base.m_init = NULL;
    1145         [ #  # ]:          0 :     Py_CLEAR(def->m_base.m_copy);
    1146                 :            :     // We leave m_index alone since there's no reason to reset it.
    1147                 :            : 
    1148                 :            :     /* Clear the PyState_*Module() cache entry. */
    1149         [ #  # ]:          0 :     if (_modules_by_index_check(interp, def->m_base.m_index) == NULL) {
    1150         [ #  # ]:          0 :         if (_modules_by_index_clear_one(interp, def) < 0) {
    1151                 :          0 :             return -1;
    1152                 :            :         }
    1153                 :            :     }
    1154                 :            : 
    1155                 :            :     /* Clear the cached module def. */
    1156         [ #  # ]:          0 :     if (_extensions_cache_delete(filename, name) < 0) {
    1157                 :          0 :         return -1;
    1158                 :            :     }
    1159                 :            : 
    1160                 :          0 :     return 0;
    1161                 :            : }
    1162                 :            : 
    1163                 :            : 
    1164                 :            : /*******************/
    1165                 :            : /* builtin modules */
    1166                 :            : /*******************/
    1167                 :            : 
    1168                 :            : int
    1169                 :         58 : _PyImport_FixupBuiltin(PyObject *mod, const char *name, PyObject *modules)
    1170                 :            : {
    1171                 :         58 :     int res = -1;
    1172                 :            :     PyObject *nameobj;
    1173                 :         58 :     nameobj = PyUnicode_InternFromString(name);
    1174         [ -  + ]:         58 :     if (nameobj == NULL) {
    1175                 :          0 :         return -1;
    1176                 :            :     }
    1177         [ -  + ]:         58 :     if (PyObject_SetItem(modules, nameobj, mod) < 0) {
    1178                 :          0 :         goto finally;
    1179                 :            :     }
    1180         [ -  + ]:         58 :     if (fix_up_extension(mod, nameobj, nameobj) < 0) {
    1181                 :          0 :         PyMapping_DelItem(modules, nameobj);
    1182                 :          0 :         goto finally;
    1183                 :            :     }
    1184                 :         58 :     res = 0;
    1185                 :            : 
    1186                 :         58 : finally:
    1187                 :         58 :     Py_DECREF(nameobj);
    1188                 :         58 :     return res;
    1189                 :            : }
    1190                 :            : 
    1191                 :            : /* Helper to test for built-in module */
    1192                 :            : 
    1193                 :            : static int
    1194                 :        875 : is_builtin(PyObject *name)
    1195                 :            : {
    1196                 :            :     int i;
    1197                 :        875 :     struct _inittab *inittab = INITTAB;
    1198         [ +  + ]:      22146 :     for (i = 0; inittab[i].name != NULL; i++) {
    1199         [ +  + ]:      21564 :         if (_PyUnicode_EqualToASCIIString(name, inittab[i].name)) {
    1200         [ -  + ]:        293 :             if (inittab[i].initfunc == NULL)
    1201                 :          0 :                 return -1;
    1202                 :            :             else
    1203                 :        293 :                 return 1;
    1204                 :            :         }
    1205                 :            :     }
    1206                 :        582 :     return 0;
    1207                 :            : }
    1208                 :            : 
    1209                 :            : static PyObject*
    1210                 :        348 : create_builtin(PyThreadState *tstate, PyObject *name, PyObject *spec)
    1211                 :            : {
    1212                 :        348 :     PyObject *mod = import_find_extension(tstate, name, name);
    1213   [ +  +  -  + ]:        348 :     if (mod || _PyErr_Occurred(tstate)) {
    1214                 :          3 :         return mod;
    1215                 :            :     }
    1216                 :            : 
    1217                 :        345 :     PyObject *modules = MODULES(tstate->interp);
    1218         [ +  - ]:       5082 :     for (struct _inittab *p = INITTAB; p->name != NULL; p++) {
    1219         [ +  + ]:       5082 :         if (_PyUnicode_EqualToASCIIString(name, p->name)) {
    1220         [ -  + ]:        345 :             if (p->initfunc == NULL) {
    1221                 :            :                 /* Cannot re-init internal module ("sys" or "builtins") */
    1222                 :          0 :                 mod = PyImport_AddModuleObject(name);
    1223                 :          0 :                 return Py_XNewRef(mod);
    1224                 :            :             }
    1225                 :        345 :             mod = _PyImport_InitFunc_TrampolineCall(*p->initfunc);
    1226         [ -  + ]:        345 :             if (mod == NULL) {
    1227                 :          0 :                 return NULL;
    1228                 :            :             }
    1229                 :            : 
    1230         [ +  + ]:        345 :             if (PyObject_TypeCheck(mod, &PyModuleDef_Type)) {
    1231                 :        319 :                 return PyModule_FromDefAndSpec((PyModuleDef*)mod, spec);
    1232                 :            :             }
    1233                 :            :             else {
    1234                 :            :                 /* Remember pointer to module init function. */
    1235                 :         26 :                 PyModuleDef *def = PyModule_GetDef(mod);
    1236         [ -  + ]:         26 :                 if (def == NULL) {
    1237                 :          0 :                     return NULL;
    1238                 :            :                 }
    1239                 :            : 
    1240                 :         26 :                 def->m_base.m_init = p->initfunc;
    1241         [ -  + ]:         26 :                 if (_PyImport_FixupExtensionObject(mod, name, name,
    1242                 :            :                                                    modules) < 0) {
    1243                 :          0 :                     return NULL;
    1244                 :            :                 }
    1245                 :         26 :                 return mod;
    1246                 :            :             }
    1247                 :            :         }
    1248                 :            :     }
    1249                 :            : 
    1250                 :            :     // not found
    1251                 :          0 :     Py_RETURN_NONE;
    1252                 :            : }
    1253                 :            : 
    1254                 :            : 
    1255                 :            : /*****************************/
    1256                 :            : /* the builtin modules table */
    1257                 :            : /*****************************/
    1258                 :            : 
    1259                 :            : /* API for embedding applications that want to add their own entries
    1260                 :            :    to the table of built-in modules.  This should normally be called
    1261                 :            :    *before* Py_Initialize().  When the table resize fails, -1 is
    1262                 :            :    returned and the existing table is unchanged.
    1263                 :            : 
    1264                 :            :    After a similar function by Just van Rossum. */
    1265                 :            : 
    1266                 :            : int
    1267                 :          0 : PyImport_ExtendInittab(struct _inittab *newtab)
    1268                 :            : {
    1269                 :            :     struct _inittab *p;
    1270                 :            :     size_t i, n;
    1271                 :          0 :     int res = 0;
    1272                 :            : 
    1273         [ #  # ]:          0 :     if (INITTAB != NULL) {
    1274                 :          0 :         Py_FatalError("PyImport_ExtendInittab() may not be called after Py_Initialize()");
    1275                 :            :     }
    1276                 :            : 
    1277                 :            :     /* Count the number of entries in both tables */
    1278         [ #  # ]:          0 :     for (n = 0; newtab[n].name != NULL; n++)
    1279                 :            :         ;
    1280         [ #  # ]:          0 :     if (n == 0)
    1281                 :          0 :         return 0; /* Nothing to do */
    1282         [ #  # ]:          0 :     for (i = 0; PyImport_Inittab[i].name != NULL; i++)
    1283                 :            :         ;
    1284                 :            : 
    1285                 :            :     /* Force default raw memory allocator to get a known allocator to be able
    1286                 :            :        to release the memory in _PyImport_Fini2() */
    1287                 :            :     PyMemAllocatorEx old_alloc;
    1288                 :          0 :     _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
    1289                 :            : 
    1290                 :            :     /* Allocate new memory for the combined table */
    1291                 :          0 :     p = NULL;
    1292         [ #  # ]:          0 :     if (i + n <= SIZE_MAX / sizeof(struct _inittab) - 1) {
    1293                 :          0 :         size_t size = sizeof(struct _inittab) * (i + n + 1);
    1294                 :          0 :         p = PyMem_RawRealloc(inittab_copy, size);
    1295                 :            :     }
    1296         [ #  # ]:          0 :     if (p == NULL) {
    1297                 :          0 :         res = -1;
    1298                 :          0 :         goto done;
    1299                 :            :     }
    1300                 :            : 
    1301                 :            :     /* Copy the tables into the new memory at the first call
    1302                 :            :        to PyImport_ExtendInittab(). */
    1303         [ #  # ]:          0 :     if (inittab_copy != PyImport_Inittab) {
    1304                 :          0 :         memcpy(p, PyImport_Inittab, (i+1) * sizeof(struct _inittab));
    1305                 :            :     }
    1306                 :          0 :     memcpy(p + i, newtab, (n + 1) * sizeof(struct _inittab));
    1307                 :          0 :     PyImport_Inittab = inittab_copy = p;
    1308                 :            : 
    1309                 :          0 : done:
    1310                 :          0 :     PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
    1311                 :          0 :     return res;
    1312                 :            : }
    1313                 :            : 
    1314                 :            : /* Shorthand to add a single entry given a name and a function */
    1315                 :            : 
    1316                 :            : int
    1317                 :          0 : PyImport_AppendInittab(const char *name, PyObject* (*initfunc)(void))
    1318                 :            : {
    1319                 :            :     struct _inittab newtab[2];
    1320                 :            : 
    1321         [ #  # ]:          0 :     if (INITTAB != NULL) {
    1322                 :          0 :         Py_FatalError("PyImport_AppendInittab() may not be called after Py_Initialize()");
    1323                 :            :     }
    1324                 :            : 
    1325                 :          0 :     memset(newtab, '\0', sizeof newtab);
    1326                 :            : 
    1327                 :          0 :     newtab[0].name = name;
    1328                 :          0 :     newtab[0].initfunc = initfunc;
    1329                 :            : 
    1330                 :          0 :     return PyImport_ExtendInittab(newtab);
    1331                 :            : }
    1332                 :            : 
    1333                 :            : 
    1334                 :            : /* the internal table */
    1335                 :            : 
    1336                 :            : static int
    1337                 :         29 : init_builtin_modules_table(void)
    1338                 :            : {
    1339                 :            :     size_t size;
    1340         [ +  + ]:        899 :     for (size = 0; PyImport_Inittab[size].name != NULL; size++)
    1341                 :            :         ;
    1342                 :         29 :     size++;
    1343                 :            : 
    1344                 :            :     /* Make the copy. */
    1345                 :         29 :     struct _inittab *copied = PyMem_RawMalloc(size * sizeof(struct _inittab));
    1346         [ -  + ]:         29 :     if (copied == NULL) {
    1347                 :          0 :         return -1;
    1348                 :            :     }
    1349                 :         29 :     memcpy(copied, PyImport_Inittab, size * sizeof(struct _inittab));
    1350                 :         29 :     INITTAB = copied;
    1351                 :         29 :     return 0;
    1352                 :            : }
    1353                 :            : 
    1354                 :            : static void
    1355                 :         25 : fini_builtin_modules_table(void)
    1356                 :            : {
    1357                 :         25 :     struct _inittab *inittab = INITTAB;
    1358                 :         25 :     INITTAB = NULL;
    1359                 :         25 :     PyMem_RawFree(inittab);
    1360                 :         25 : }
    1361                 :            : 
    1362                 :            : PyObject *
    1363                 :         29 : _PyImport_GetBuiltinModuleNames(void)
    1364                 :            : {
    1365                 :         29 :     PyObject *list = PyList_New(0);
    1366         [ -  + ]:         29 :     if (list == NULL) {
    1367                 :          0 :         return NULL;
    1368                 :            :     }
    1369                 :         29 :     struct _inittab *inittab = INITTAB;
    1370         [ +  + ]:        899 :     for (Py_ssize_t i = 0; inittab[i].name != NULL; i++) {
    1371                 :        870 :         PyObject *name = PyUnicode_FromString(inittab[i].name);
    1372         [ -  + ]:        870 :         if (name == NULL) {
    1373                 :          0 :             Py_DECREF(list);
    1374                 :          0 :             return NULL;
    1375                 :            :         }
    1376         [ -  + ]:        870 :         if (PyList_Append(list, name) < 0) {
    1377                 :          0 :             Py_DECREF(name);
    1378                 :          0 :             Py_DECREF(list);
    1379                 :          0 :             return NULL;
    1380                 :            :         }
    1381                 :        870 :         Py_DECREF(name);
    1382                 :            :     }
    1383                 :         29 :     return list;
    1384                 :            : }
    1385                 :            : 
    1386                 :            : 
    1387                 :            : /********************/
    1388                 :            : /* the magic number */
    1389                 :            : /********************/
    1390                 :            : 
    1391                 :            : /* Helper for pythonrun.c -- return magic number and tag. */
    1392                 :            : 
    1393                 :            : long
    1394                 :         22 : PyImport_GetMagicNumber(void)
    1395                 :            : {
    1396                 :            :     long res;
    1397                 :         22 :     PyInterpreterState *interp = _PyInterpreterState_GET();
    1398                 :            :     PyObject *external, *pyc_magic;
    1399                 :            : 
    1400                 :         22 :     external = PyObject_GetAttrString(IMPORTLIB(interp), "_bootstrap_external");
    1401         [ -  + ]:         22 :     if (external == NULL)
    1402                 :          0 :         return -1;
    1403                 :         22 :     pyc_magic = PyObject_GetAttrString(external, "_RAW_MAGIC_NUMBER");
    1404                 :         22 :     Py_DECREF(external);
    1405         [ -  + ]:         22 :     if (pyc_magic == NULL)
    1406                 :          0 :         return -1;
    1407                 :         22 :     res = PyLong_AsLong(pyc_magic);
    1408                 :         22 :     Py_DECREF(pyc_magic);
    1409                 :         22 :     return res;
    1410                 :            : }
    1411                 :            : 
    1412                 :            : 
    1413                 :            : extern const char * _PySys_ImplCacheTag;
    1414                 :            : 
    1415                 :            : const char *
    1416                 :          0 : PyImport_GetMagicTag(void)
    1417                 :            : {
    1418                 :          0 :     return _PySys_ImplCacheTag;
    1419                 :            : }
    1420                 :            : 
    1421                 :            : 
    1422                 :            : /*********************************/
    1423                 :            : /* a Python module's code object */
    1424                 :            : /*********************************/
    1425                 :            : 
    1426                 :            : /* Execute a code object in a module and return the module object
    1427                 :            :  * WITH INCREMENTED REFERENCE COUNT.  If an error occurs, name is
    1428                 :            :  * removed from sys.modules, to avoid leaving damaged module objects
    1429                 :            :  * in sys.modules.  The caller may wish to restore the original
    1430                 :            :  * module object (if any) in this case; PyImport_ReloadModule is an
    1431                 :            :  * example.
    1432                 :            :  *
    1433                 :            :  * Note that PyImport_ExecCodeModuleWithPathnames() is the preferred, richer
    1434                 :            :  * interface.  The other two exist primarily for backward compatibility.
    1435                 :            :  */
    1436                 :            : PyObject *
    1437                 :          0 : PyImport_ExecCodeModule(const char *name, PyObject *co)
    1438                 :            : {
    1439                 :          0 :     return PyImport_ExecCodeModuleWithPathnames(
    1440                 :            :         name, co, (char *)NULL, (char *)NULL);
    1441                 :            : }
    1442                 :            : 
    1443                 :            : PyObject *
    1444                 :          0 : PyImport_ExecCodeModuleEx(const char *name, PyObject *co, const char *pathname)
    1445                 :            : {
    1446                 :          0 :     return PyImport_ExecCodeModuleWithPathnames(
    1447                 :            :         name, co, pathname, (char *)NULL);
    1448                 :            : }
    1449                 :            : 
    1450                 :            : PyObject *
    1451                 :          0 : PyImport_ExecCodeModuleWithPathnames(const char *name, PyObject *co,
    1452                 :            :                                      const char *pathname,
    1453                 :            :                                      const char *cpathname)
    1454                 :            : {
    1455                 :          0 :     PyObject *m = NULL;
    1456                 :          0 :     PyObject *nameobj, *pathobj = NULL, *cpathobj = NULL, *external= NULL;
    1457                 :            : 
    1458                 :          0 :     nameobj = PyUnicode_FromString(name);
    1459         [ #  # ]:          0 :     if (nameobj == NULL)
    1460                 :          0 :         return NULL;
    1461                 :            : 
    1462         [ #  # ]:          0 :     if (cpathname != NULL) {
    1463                 :          0 :         cpathobj = PyUnicode_DecodeFSDefault(cpathname);
    1464         [ #  # ]:          0 :         if (cpathobj == NULL)
    1465                 :          0 :             goto error;
    1466                 :            :     }
    1467                 :            :     else
    1468                 :          0 :         cpathobj = NULL;
    1469                 :            : 
    1470         [ #  # ]:          0 :     if (pathname != NULL) {
    1471                 :          0 :         pathobj = PyUnicode_DecodeFSDefault(pathname);
    1472         [ #  # ]:          0 :         if (pathobj == NULL)
    1473                 :          0 :             goto error;
    1474                 :            :     }
    1475         [ #  # ]:          0 :     else if (cpathobj != NULL) {
    1476                 :          0 :         PyInterpreterState *interp = _PyInterpreterState_GET();
    1477                 :            : 
    1478         [ #  # ]:          0 :         if (interp == NULL) {
    1479                 :          0 :             Py_FatalError("no current interpreter");
    1480                 :            :         }
    1481                 :            : 
    1482                 :          0 :         external= PyObject_GetAttrString(IMPORTLIB(interp),
    1483                 :            :                                          "_bootstrap_external");
    1484         [ #  # ]:          0 :         if (external != NULL) {
    1485                 :          0 :             pathobj = _PyObject_CallMethodOneArg(
    1486                 :            :                 external, &_Py_ID(_get_sourcefile), cpathobj);
    1487                 :          0 :             Py_DECREF(external);
    1488                 :            :         }
    1489         [ #  # ]:          0 :         if (pathobj == NULL)
    1490                 :          0 :             PyErr_Clear();
    1491                 :            :     }
    1492                 :            :     else
    1493                 :          0 :         pathobj = NULL;
    1494                 :            : 
    1495                 :          0 :     m = PyImport_ExecCodeModuleObject(nameobj, co, pathobj, cpathobj);
    1496                 :          0 : error:
    1497                 :          0 :     Py_DECREF(nameobj);
    1498                 :          0 :     Py_XDECREF(pathobj);
    1499                 :          0 :     Py_XDECREF(cpathobj);
    1500                 :          0 :     return m;
    1501                 :            : }
    1502                 :            : 
    1503                 :            : static PyObject *
    1504                 :         25 : module_dict_for_exec(PyThreadState *tstate, PyObject *name)
    1505                 :            : {
    1506                 :            :     PyObject *m, *d;
    1507                 :            : 
    1508                 :         25 :     m = import_add_module(tstate, name);
    1509         [ -  + ]:         25 :     if (m == NULL)
    1510                 :          0 :         return NULL;
    1511                 :            :     /* If the module is being reloaded, we get the old module back
    1512                 :            :        and re-use its dict to exec the new code. */
    1513                 :         25 :     d = PyModule_GetDict(m);
    1514                 :         25 :     int r = PyDict_Contains(d, &_Py_ID(__builtins__));
    1515         [ +  - ]:         25 :     if (r == 0) {
    1516                 :         25 :         r = PyDict_SetItem(d, &_Py_ID(__builtins__), PyEval_GetBuiltins());
    1517                 :            :     }
    1518         [ -  + ]:         25 :     if (r < 0) {
    1519                 :          0 :         remove_module(tstate, name);
    1520                 :          0 :         Py_DECREF(m);
    1521                 :          0 :         return NULL;
    1522                 :            :     }
    1523                 :            : 
    1524                 :         25 :     Py_INCREF(d);
    1525                 :         25 :     Py_DECREF(m);
    1526                 :         25 :     return d;
    1527                 :            : }
    1528                 :            : 
    1529                 :            : static PyObject *
    1530                 :         25 : exec_code_in_module(PyThreadState *tstate, PyObject *name,
    1531                 :            :                     PyObject *module_dict, PyObject *code_object)
    1532                 :            : {
    1533                 :            :     PyObject *v, *m;
    1534                 :            : 
    1535                 :         25 :     v = PyEval_EvalCode(code_object, module_dict, module_dict);
    1536         [ -  + ]:         25 :     if (v == NULL) {
    1537                 :          0 :         remove_module(tstate, name);
    1538                 :          0 :         return NULL;
    1539                 :            :     }
    1540                 :         25 :     Py_DECREF(v);
    1541                 :            : 
    1542                 :         25 :     m = import_get_module(tstate, name);
    1543   [ -  +  -  - ]:         25 :     if (m == NULL && !_PyErr_Occurred(tstate)) {
    1544                 :          0 :         _PyErr_Format(tstate, PyExc_ImportError,
    1545                 :            :                       "Loaded module %R not found in sys.modules",
    1546                 :            :                       name);
    1547                 :            :     }
    1548                 :            : 
    1549                 :         25 :     return m;
    1550                 :            : }
    1551                 :            : 
    1552                 :            : PyObject*
    1553                 :          0 : PyImport_ExecCodeModuleObject(PyObject *name, PyObject *co, PyObject *pathname,
    1554                 :            :                               PyObject *cpathname)
    1555                 :            : {
    1556                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    1557                 :            :     PyObject *d, *external, *res;
    1558                 :            : 
    1559                 :          0 :     d = module_dict_for_exec(tstate, name);
    1560         [ #  # ]:          0 :     if (d == NULL) {
    1561                 :          0 :         return NULL;
    1562                 :            :     }
    1563                 :            : 
    1564         [ #  # ]:          0 :     if (pathname == NULL) {
    1565                 :          0 :         pathname = ((PyCodeObject *)co)->co_filename;
    1566                 :            :     }
    1567                 :          0 :     external = PyObject_GetAttrString(IMPORTLIB(tstate->interp),
    1568                 :            :                                       "_bootstrap_external");
    1569         [ #  # ]:          0 :     if (external == NULL) {
    1570                 :          0 :         Py_DECREF(d);
    1571                 :          0 :         return NULL;
    1572                 :            :     }
    1573                 :          0 :     res = PyObject_CallMethodObjArgs(external, &_Py_ID(_fix_up_module),
    1574                 :            :                                      d, name, pathname, cpathname, NULL);
    1575                 :          0 :     Py_DECREF(external);
    1576         [ #  # ]:          0 :     if (res != NULL) {
    1577                 :          0 :         Py_DECREF(res);
    1578                 :          0 :         res = exec_code_in_module(tstate, name, d, co);
    1579                 :            :     }
    1580                 :          0 :     Py_DECREF(d);
    1581                 :          0 :     return res;
    1582                 :            : }
    1583                 :            : 
    1584                 :            : 
    1585                 :            : static void
    1586                 :          0 : update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
    1587                 :            : {
    1588                 :            :     PyObject *constants, *tmp;
    1589                 :            :     Py_ssize_t i, n;
    1590                 :            : 
    1591         [ #  # ]:          0 :     if (PyUnicode_Compare(co->co_filename, oldname))
    1592                 :          0 :         return;
    1593                 :            : 
    1594                 :          0 :     Py_XSETREF(co->co_filename, Py_NewRef(newname));
    1595                 :            : 
    1596                 :          0 :     constants = co->co_consts;
    1597                 :          0 :     n = PyTuple_GET_SIZE(constants);
    1598         [ #  # ]:          0 :     for (i = 0; i < n; i++) {
    1599                 :          0 :         tmp = PyTuple_GET_ITEM(constants, i);
    1600         [ #  # ]:          0 :         if (PyCode_Check(tmp))
    1601                 :          0 :             update_code_filenames((PyCodeObject *)tmp,
    1602                 :            :                                   oldname, newname);
    1603                 :            :     }
    1604                 :            : }
    1605                 :            : 
    1606                 :            : static void
    1607                 :        386 : update_compiled_module(PyCodeObject *co, PyObject *newname)
    1608                 :            : {
    1609                 :            :     PyObject *oldname;
    1610                 :            : 
    1611         [ +  - ]:        386 :     if (PyUnicode_Compare(co->co_filename, newname) == 0)
    1612                 :        386 :         return;
    1613                 :            : 
    1614                 :          0 :     oldname = co->co_filename;
    1615                 :          0 :     Py_INCREF(oldname);
    1616                 :          0 :     update_code_filenames(co, oldname, newname);
    1617                 :          0 :     Py_DECREF(oldname);
    1618                 :            : }
    1619                 :            : 
    1620                 :            : 
    1621                 :            : /******************/
    1622                 :            : /* frozen modules */
    1623                 :            : /******************/
    1624                 :            : 
    1625                 :            : /* Return true if the name is an alias.  In that case, "alias" is set
    1626                 :            :    to the original module name.  If it is an alias but the original
    1627                 :            :    module isn't known then "alias" is set to NULL while true is returned. */
    1628                 :            : static bool
    1629                 :        269 : resolve_module_alias(const char *name, const struct _module_alias *aliases,
    1630                 :            :                      const char **alias)
    1631                 :            : {
    1632                 :            :     const struct _module_alias *entry;
    1633                 :       1321 :     for (entry = aliases; ; entry++) {
    1634         [ +  + ]:       1321 :         if (entry->name == NULL) {
    1635                 :            :             /* It isn't an alias. */
    1636                 :        144 :             return false;
    1637                 :            :         }
    1638         [ +  + ]:       1177 :         if (strcmp(name, entry->name) == 0) {
    1639         [ +  - ]:        125 :             if (alias != NULL) {
    1640                 :        125 :                 *alias = entry->orig;
    1641                 :            :             }
    1642                 :        125 :             return true;
    1643                 :            :         }
    1644                 :            :     }
    1645                 :            : }
    1646                 :            : 
    1647                 :            : static bool
    1648                 :        717 : use_frozen(void)
    1649                 :            : {
    1650                 :        717 :     PyInterpreterState *interp = _PyInterpreterState_GET();
    1651                 :        717 :     int override = OVERRIDE_FROZEN_MODULES(interp);
    1652         [ -  + ]:        717 :     if (override > 0) {
    1653                 :          0 :         return true;
    1654                 :            :     }
    1655         [ -  + ]:        717 :     else if (override < 0) {
    1656                 :          0 :         return false;
    1657                 :            :     }
    1658                 :            :     else {
    1659                 :        717 :         return interp->config.use_frozen_modules;
    1660                 :            :     }
    1661                 :            : }
    1662                 :            : 
    1663                 :            : static PyObject *
    1664                 :          0 : list_frozen_module_names(void)
    1665                 :            : {
    1666                 :          0 :     PyObject *names = PyList_New(0);
    1667         [ #  # ]:          0 :     if (names == NULL) {
    1668                 :          0 :         return NULL;
    1669                 :            :     }
    1670                 :          0 :     bool enabled = use_frozen();
    1671                 :            :     const struct _frozen *p;
    1672                 :            : #define ADD_MODULE(name) \
    1673                 :            :     do { \
    1674                 :            :         PyObject *nameobj = PyUnicode_FromString(name); \
    1675                 :            :         if (nameobj == NULL) { \
    1676                 :            :             goto error; \
    1677                 :            :         } \
    1678                 :            :         int res = PyList_Append(names, nameobj); \
    1679                 :            :         Py_DECREF(nameobj); \
    1680                 :            :         if (res != 0) { \
    1681                 :            :             goto error; \
    1682                 :            :         } \
    1683                 :            :     } while(0)
    1684                 :            :     // We always use the bootstrap modules.
    1685                 :          0 :     for (p = _PyImport_FrozenBootstrap; ; p++) {
    1686         [ #  # ]:          0 :         if (p->name == NULL) {
    1687                 :          0 :             break;
    1688                 :            :         }
    1689   [ #  #  #  # ]:          0 :         ADD_MODULE(p->name);
    1690                 :            :     }
    1691                 :            :     // Frozen stdlib modules may be disabled.
    1692                 :          0 :     for (p = _PyImport_FrozenStdlib; ; p++) {
    1693         [ #  # ]:          0 :         if (p->name == NULL) {
    1694                 :          0 :             break;
    1695                 :            :         }
    1696         [ #  # ]:          0 :         if (enabled) {
    1697   [ #  #  #  # ]:          0 :             ADD_MODULE(p->name);
    1698                 :            :         }
    1699                 :            :     }
    1700                 :          0 :     for (p = _PyImport_FrozenTest; ; p++) {
    1701         [ #  # ]:          0 :         if (p->name == NULL) {
    1702                 :          0 :             break;
    1703                 :            :         }
    1704         [ #  # ]:          0 :         if (enabled) {
    1705   [ #  #  #  # ]:          0 :             ADD_MODULE(p->name);
    1706                 :            :         }
    1707                 :            :     }
    1708                 :            : #undef ADD_MODULE
    1709                 :            :     // Add any custom modules.
    1710         [ #  # ]:          0 :     if (PyImport_FrozenModules != NULL) {
    1711                 :          0 :         for (p = PyImport_FrozenModules; ; p++) {
    1712         [ #  # ]:          0 :             if (p->name == NULL) {
    1713                 :          0 :                 break;
    1714                 :            :             }
    1715                 :          0 :             PyObject *nameobj = PyUnicode_FromString(p->name);
    1716         [ #  # ]:          0 :             if (nameobj == NULL) {
    1717                 :          0 :                 goto error;
    1718                 :            :             }
    1719                 :          0 :             int found = PySequence_Contains(names, nameobj);
    1720         [ #  # ]:          0 :             if (found < 0) {
    1721                 :          0 :                 Py_DECREF(nameobj);
    1722                 :          0 :                 goto error;
    1723                 :            :             }
    1724         [ #  # ]:          0 :             else if (found) {
    1725                 :          0 :                 Py_DECREF(nameobj);
    1726                 :            :             }
    1727                 :            :             else {
    1728                 :          0 :                 int res = PyList_Append(names, nameobj);
    1729                 :          0 :                 Py_DECREF(nameobj);
    1730         [ #  # ]:          0 :                 if (res != 0) {
    1731                 :          0 :                     goto error;
    1732                 :            :                 }
    1733                 :            :             }
    1734                 :            :         }
    1735                 :            :     }
    1736                 :          0 :     return names;
    1737                 :            : 
    1738                 :          0 : error:
    1739                 :          0 :     Py_DECREF(names);
    1740                 :          0 :     return NULL;
    1741                 :            : }
    1742                 :            : 
    1743                 :            : typedef enum {
    1744                 :            :     FROZEN_OKAY,
    1745                 :            :     FROZEN_BAD_NAME,    // The given module name wasn't valid.
    1746                 :            :     FROZEN_NOT_FOUND,   // It wasn't in PyImport_FrozenModules.
    1747                 :            :     FROZEN_DISABLED,    // -X frozen_modules=off (and not essential)
    1748                 :            :     FROZEN_EXCLUDED,    /* The PyImport_FrozenModules entry has NULL "code"
    1749                 :            :                            (module is present but marked as unimportable, stops search). */
    1750                 :            :     FROZEN_INVALID,     /* The PyImport_FrozenModules entry is bogus
    1751                 :            :                            (eg. does not contain executable code). */
    1752                 :            : } frozen_status;
    1753                 :            : 
    1754                 :            : static inline void
    1755                 :          0 : set_frozen_error(frozen_status status, PyObject *modname)
    1756                 :            : {
    1757                 :          0 :     const char *err = NULL;
    1758   [ #  #  #  #  :          0 :     switch (status) {
                   #  # ]
    1759                 :          0 :         case FROZEN_BAD_NAME:
    1760                 :            :         case FROZEN_NOT_FOUND:
    1761                 :          0 :             err = "No such frozen object named %R";
    1762                 :          0 :             break;
    1763                 :          0 :         case FROZEN_DISABLED:
    1764                 :          0 :             err = "Frozen modules are disabled and the frozen object named %R is not essential";
    1765                 :          0 :             break;
    1766                 :          0 :         case FROZEN_EXCLUDED:
    1767                 :          0 :             err = "Excluded frozen object named %R";
    1768                 :          0 :             break;
    1769                 :          0 :         case FROZEN_INVALID:
    1770                 :          0 :             err = "Frozen object named %R is invalid";
    1771                 :          0 :             break;
    1772                 :          0 :         case FROZEN_OKAY:
    1773                 :            :             // There was no error.
    1774                 :          0 :             break;
    1775                 :          0 :         default:
    1776                 :          0 :             Py_UNREACHABLE();
    1777                 :            :     }
    1778         [ #  # ]:          0 :     if (err != NULL) {
    1779                 :          0 :         PyObject *msg = PyUnicode_FromFormat(err, modname);
    1780         [ #  # ]:          0 :         if (msg == NULL) {
    1781                 :          0 :             PyErr_Clear();
    1782                 :            :         }
    1783                 :          0 :         PyErr_SetImportError(msg, modname, NULL);
    1784                 :          0 :         Py_XDECREF(msg);
    1785                 :            :     }
    1786                 :          0 : }
    1787                 :            : 
    1788                 :            : static const struct _frozen *
    1789                 :        892 : look_up_frozen(const char *name)
    1790                 :            : {
    1791                 :            :     const struct _frozen *p;
    1792                 :            :     // We always use the bootstrap modules.
    1793                 :       3193 :     for (p = _PyImport_FrozenBootstrap; ; p++) {
    1794         [ +  + ]:       3193 :         if (p->name == NULL) {
    1795                 :            :             // We hit the end-of-list sentinel value.
    1796                 :        717 :             break;
    1797                 :            :         }
    1798         [ +  + ]:       2476 :         if (strcmp(name, p->name) == 0) {
    1799                 :        175 :             return p;
    1800                 :            :         }
    1801                 :            :     }
    1802                 :            :     // Prefer custom modules, if any.  Frozen stdlib modules can be
    1803                 :            :     // disabled here by setting "code" to NULL in the array entry.
    1804         [ -  + ]:        717 :     if (PyImport_FrozenModules != NULL) {
    1805                 :          0 :         for (p = PyImport_FrozenModules; ; p++) {
    1806         [ #  # ]:          0 :             if (p->name == NULL) {
    1807                 :          0 :                 break;
    1808                 :            :             }
    1809         [ #  # ]:          0 :             if (strcmp(name, p->name) == 0) {
    1810                 :          0 :                 return p;
    1811                 :            :             }
    1812                 :            :         }
    1813                 :            :     }
    1814                 :            :     // Frozen stdlib modules may be disabled.
    1815         [ +  - ]:        717 :     if (use_frozen()) {
    1816                 :       5763 :         for (p = _PyImport_FrozenStdlib; ; p++) {
    1817         [ +  + ]:       5763 :             if (p->name == NULL) {
    1818                 :        623 :                 break;
    1819                 :            :             }
    1820         [ +  + ]:       5140 :             if (strcmp(name, p->name) == 0) {
    1821                 :         94 :                 return p;
    1822                 :            :             }
    1823                 :            :         }
    1824                 :       3879 :         for (p = _PyImport_FrozenTest; ; p++) {
    1825         [ +  + ]:       3879 :             if (p->name == NULL) {
    1826                 :        623 :                 break;
    1827                 :            :             }
    1828         [ -  + ]:       3256 :             if (strcmp(name, p->name) == 0) {
    1829                 :          0 :                 return p;
    1830                 :            :             }
    1831                 :            :         }
    1832                 :            :     }
    1833                 :        623 :     return NULL;
    1834                 :            : }
    1835                 :            : 
    1836                 :            : struct frozen_info {
    1837                 :            :     PyObject *nameobj;
    1838                 :            :     const char *data;
    1839                 :            :     PyObject *(*get_code)(void);
    1840                 :            :     Py_ssize_t size;
    1841                 :            :     bool is_package;
    1842                 :            :     bool is_alias;
    1843                 :            :     const char *origname;
    1844                 :            : };
    1845                 :            : 
    1846                 :            : static frozen_status
    1847                 :        892 : find_frozen(PyObject *nameobj, struct frozen_info *info)
    1848                 :            : {
    1849         [ +  - ]:        892 :     if (info != NULL) {
    1850                 :        892 :         memset(info, 0, sizeof(*info));
    1851                 :            :     }
    1852                 :            : 
    1853   [ +  -  -  + ]:        892 :     if (nameobj == NULL || nameobj == Py_None) {
    1854                 :          0 :         return FROZEN_BAD_NAME;
    1855                 :            :     }
    1856                 :        892 :     const char *name = PyUnicode_AsUTF8(nameobj);
    1857         [ -  + ]:        892 :     if (name == NULL) {
    1858                 :            :         // Note that this function previously used
    1859                 :            :         // _PyUnicode_EqualToASCIIString().  We clear the error here
    1860                 :            :         // (instead of propagating it) to match the earlier behavior
    1861                 :            :         // more closely.
    1862                 :          0 :         PyErr_Clear();
    1863                 :          0 :         return FROZEN_BAD_NAME;
    1864                 :            :     }
    1865                 :            : 
    1866                 :        892 :     const struct _frozen *p = look_up_frozen(name);
    1867         [ +  + ]:        892 :     if (p == NULL) {
    1868                 :        623 :         return FROZEN_NOT_FOUND;
    1869                 :            :     }
    1870         [ +  - ]:        269 :     if (info != NULL) {
    1871                 :        269 :         info->nameobj = nameobj;  // borrowed
    1872                 :        269 :         info->data = (const char *)p->code;
    1873                 :        269 :         info->get_code = p->get_code;
    1874                 :        269 :         info->size = p->size;
    1875                 :        269 :         info->is_package = p->is_package;
    1876         [ -  + ]:        269 :         if (p->size < 0) {
    1877                 :            :             // backward compatibility with negative size values
    1878                 :          0 :             info->size = -(p->size);
    1879                 :          0 :             info->is_package = true;
    1880                 :            :         }
    1881                 :        269 :         info->origname = name;
    1882                 :        269 :         info->is_alias = resolve_module_alias(name, _PyImport_FrozenAliases,
    1883                 :            :                                               &info->origname);
    1884                 :            :     }
    1885   [ +  +  +  -  :        269 :     if (p->code == NULL && p->size == 0 && p->get_code != NULL) {
                   +  - ]
    1886                 :            :         /* It is only deepfrozen. */
    1887                 :        122 :         return FROZEN_OKAY;
    1888                 :            :     }
    1889         [ -  + ]:        147 :     if (p->code == NULL) {
    1890                 :            :         /* It is frozen but marked as un-importable. */
    1891                 :          0 :         return FROZEN_EXCLUDED;
    1892                 :            :     }
    1893   [ +  -  -  + ]:        147 :     if (p->code[0] == '\0' || p->size == 0) {
    1894                 :            :         /* Does not contain executable code. */
    1895                 :          0 :         return FROZEN_INVALID;
    1896                 :            :     }
    1897                 :        147 :     return FROZEN_OKAY;
    1898                 :            : }
    1899                 :            : 
    1900                 :            : static PyObject *
    1901                 :        122 : unmarshal_frozen_code(struct frozen_info *info)
    1902                 :            : {
    1903         [ +  + ]:        122 :     if (info->get_code) {
    1904                 :         59 :         PyObject *code = info->get_code();
    1905                 :            :         assert(code != NULL);
    1906                 :         59 :         return code;
    1907                 :            :     }
    1908                 :         63 :     PyObject *co = PyMarshal_ReadObjectFromString(info->data, info->size);
    1909         [ -  + ]:         63 :     if (co == NULL) {
    1910                 :            :         /* Does not contain executable code. */
    1911                 :          0 :         set_frozen_error(FROZEN_INVALID, info->nameobj);
    1912                 :          0 :         return NULL;
    1913                 :            :     }
    1914         [ -  + ]:         63 :     if (!PyCode_Check(co)) {
    1915                 :            :         // We stick with TypeError for backward compatibility.
    1916                 :          0 :         PyErr_Format(PyExc_TypeError,
    1917                 :            :                      "frozen object %R is not a code object",
    1918                 :            :                      info->nameobj);
    1919                 :          0 :         Py_DECREF(co);
    1920                 :          0 :         return NULL;
    1921                 :            :     }
    1922                 :         63 :     return co;
    1923                 :            : }
    1924                 :            : 
    1925                 :            : 
    1926                 :            : /* Initialize a frozen module.
    1927                 :            :    Return 1 for success, 0 if the module is not found, and -1 with
    1928                 :            :    an exception set if the initialization failed.
    1929                 :            :    This function is also used from frozenmain.c */
    1930                 :            : 
    1931                 :            : int
    1932                 :         25 : PyImport_ImportFrozenModuleObject(PyObject *name)
    1933                 :            : {
    1934                 :         25 :     PyThreadState *tstate = _PyThreadState_GET();
    1935                 :         25 :     PyObject *co, *m, *d = NULL;
    1936                 :            :     int err;
    1937                 :            : 
    1938                 :            :     struct frozen_info info;
    1939                 :         25 :     frozen_status status = find_frozen(name, &info);
    1940   [ +  -  -  + ]:         25 :     if (status == FROZEN_NOT_FOUND || status == FROZEN_DISABLED) {
    1941                 :          0 :         return 0;
    1942                 :            :     }
    1943         [ -  + ]:         25 :     else if (status == FROZEN_BAD_NAME) {
    1944                 :          0 :         return 0;
    1945                 :            :     }
    1946         [ -  + ]:         25 :     else if (status != FROZEN_OKAY) {
    1947                 :          0 :         set_frozen_error(status, name);
    1948                 :          0 :         return -1;
    1949                 :            :     }
    1950                 :         25 :     co = unmarshal_frozen_code(&info);
    1951         [ -  + ]:         25 :     if (co == NULL) {
    1952                 :          0 :         return -1;
    1953                 :            :     }
    1954         [ -  + ]:         25 :     if (info.is_package) {
    1955                 :            :         /* Set __path__ to the empty list */
    1956                 :            :         PyObject *l;
    1957                 :          0 :         m = import_add_module(tstate, name);
    1958         [ #  # ]:          0 :         if (m == NULL)
    1959                 :          0 :             goto err_return;
    1960                 :          0 :         d = PyModule_GetDict(m);
    1961                 :          0 :         l = PyList_New(0);
    1962         [ #  # ]:          0 :         if (l == NULL) {
    1963                 :          0 :             Py_DECREF(m);
    1964                 :          0 :             goto err_return;
    1965                 :            :         }
    1966                 :          0 :         err = PyDict_SetItemString(d, "__path__", l);
    1967                 :          0 :         Py_DECREF(l);
    1968                 :          0 :         Py_DECREF(m);
    1969         [ #  # ]:          0 :         if (err != 0)
    1970                 :          0 :             goto err_return;
    1971                 :            :     }
    1972                 :         25 :     d = module_dict_for_exec(tstate, name);
    1973         [ -  + ]:         25 :     if (d == NULL) {
    1974                 :          0 :         goto err_return;
    1975                 :            :     }
    1976                 :         25 :     m = exec_code_in_module(tstate, name, d, co);
    1977         [ -  + ]:         25 :     if (m == NULL) {
    1978                 :          0 :         goto err_return;
    1979                 :            :     }
    1980                 :         25 :     Py_DECREF(m);
    1981                 :            :     /* Set __origname__ (consumed in FrozenImporter._setup_module()). */
    1982                 :            :     PyObject *origname;
    1983         [ +  - ]:         25 :     if (info.origname) {
    1984                 :         25 :         origname = PyUnicode_FromString(info.origname);
    1985         [ -  + ]:         25 :         if (origname == NULL) {
    1986                 :          0 :             goto err_return;
    1987                 :            :         }
    1988                 :            :     }
    1989                 :            :     else {
    1990                 :          0 :         origname = Py_NewRef(Py_None);
    1991                 :            :     }
    1992                 :         25 :     err = PyDict_SetItemString(d, "__origname__", origname);
    1993                 :         25 :     Py_DECREF(origname);
    1994         [ -  + ]:         25 :     if (err != 0) {
    1995                 :          0 :         goto err_return;
    1996                 :            :     }
    1997                 :         25 :     Py_DECREF(d);
    1998                 :         25 :     Py_DECREF(co);
    1999                 :         25 :     return 1;
    2000                 :            : 
    2001                 :          0 : err_return:
    2002                 :          0 :     Py_XDECREF(d);
    2003                 :          0 :     Py_DECREF(co);
    2004                 :          0 :     return -1;
    2005                 :            : }
    2006                 :            : 
    2007                 :            : int
    2008                 :         25 : PyImport_ImportFrozenModule(const char *name)
    2009                 :            : {
    2010                 :            :     PyObject *nameobj;
    2011                 :            :     int ret;
    2012                 :         25 :     nameobj = PyUnicode_InternFromString(name);
    2013         [ -  + ]:         25 :     if (nameobj == NULL)
    2014                 :          0 :         return -1;
    2015                 :         25 :     ret = PyImport_ImportFrozenModuleObject(nameobj);
    2016                 :         25 :     Py_DECREF(nameobj);
    2017                 :         25 :     return ret;
    2018                 :            : }
    2019                 :            : 
    2020                 :            : 
    2021                 :            : /*************/
    2022                 :            : /* importlib */
    2023                 :            : /*************/
    2024                 :            : 
    2025                 :            : /* Import the _imp extension by calling manually _imp.create_builtin() and
    2026                 :            :    _imp.exec_builtin() since importlib is not initialized yet. Initializing
    2027                 :            :    importlib requires the _imp module: this function fix the bootstrap issue.
    2028                 :            :  */
    2029                 :            : static PyObject*
    2030                 :         25 : bootstrap_imp(PyThreadState *tstate)
    2031                 :            : {
    2032                 :         25 :     PyObject *name = PyUnicode_FromString("_imp");
    2033         [ -  + ]:         25 :     if (name == NULL) {
    2034                 :          0 :         return NULL;
    2035                 :            :     }
    2036                 :            : 
    2037                 :            :     // Mock a ModuleSpec object just good enough for PyModule_FromDefAndSpec():
    2038                 :            :     // an object with just a name attribute.
    2039                 :            :     //
    2040                 :            :     // _imp.__spec__ is overridden by importlib._bootstrap._instal() anyway.
    2041                 :         25 :     PyObject *attrs = Py_BuildValue("{sO}", "name", name);
    2042         [ -  + ]:         25 :     if (attrs == NULL) {
    2043                 :          0 :         goto error;
    2044                 :            :     }
    2045                 :         25 :     PyObject *spec = _PyNamespace_New(attrs);
    2046                 :         25 :     Py_DECREF(attrs);
    2047         [ -  + ]:         25 :     if (spec == NULL) {
    2048                 :          0 :         goto error;
    2049                 :            :     }
    2050                 :            : 
    2051                 :            :     // Create the _imp module from its definition.
    2052                 :         25 :     PyObject *mod = create_builtin(tstate, name, spec);
    2053         [ +  - ]:         25 :     Py_CLEAR(name);
    2054                 :         25 :     Py_DECREF(spec);
    2055         [ -  + ]:         25 :     if (mod == NULL) {
    2056                 :          0 :         goto error;
    2057                 :            :     }
    2058                 :            :     assert(mod != Py_None);  // not found
    2059                 :            : 
    2060                 :            :     // Execute the _imp module: call imp_module_exec().
    2061         [ -  + ]:         25 :     if (exec_builtin_or_dynamic(mod) < 0) {
    2062                 :          0 :         Py_DECREF(mod);
    2063                 :          0 :         goto error;
    2064                 :            :     }
    2065                 :         25 :     return mod;
    2066                 :            : 
    2067                 :          0 : error:
    2068                 :          0 :     Py_XDECREF(name);
    2069                 :          0 :     return NULL;
    2070                 :            : }
    2071                 :            : 
    2072                 :            : /* Global initializations.  Can be undone by Py_FinalizeEx().  Don't
    2073                 :            :    call this twice without an intervening Py_FinalizeEx() call.  When
    2074                 :            :    initializations fail, a fatal error is issued and the function does
    2075                 :            :    not return.  On return, the first thread and interpreter state have
    2076                 :            :    been created.
    2077                 :            : 
    2078                 :            :    Locking: you must hold the interpreter lock while calling this.
    2079                 :            :    (If the lock has not yet been initialized, that's equivalent to
    2080                 :            :    having the lock, but you cannot use multiple threads.)
    2081                 :            : 
    2082                 :            : */
    2083                 :            : static int
    2084                 :         25 : init_importlib(PyThreadState *tstate, PyObject *sysmod)
    2085                 :            : {
    2086                 :            :     assert(!_PyErr_Occurred(tstate));
    2087                 :            : 
    2088                 :         25 :     PyInterpreterState *interp = tstate->interp;
    2089                 :         25 :     int verbose = _PyInterpreterState_GetConfig(interp)->verbose;
    2090                 :            : 
    2091                 :            :     // Import _importlib through its frozen version, _frozen_importlib.
    2092         [ -  + ]:         25 :     if (verbose) {
    2093                 :          0 :         PySys_FormatStderr("import _frozen_importlib # frozen\n");
    2094                 :            :     }
    2095         [ -  + ]:         25 :     if (PyImport_ImportFrozenModule("_frozen_importlib") <= 0) {
    2096                 :          0 :         return -1;
    2097                 :            :     }
    2098                 :         25 :     PyObject *importlib = PyImport_AddModule("_frozen_importlib"); // borrowed
    2099         [ -  + ]:         25 :     if (importlib == NULL) {
    2100                 :          0 :         return -1;
    2101                 :            :     }
    2102                 :         25 :     IMPORTLIB(interp) = Py_NewRef(importlib);
    2103                 :            : 
    2104                 :            :     // Import the _imp module
    2105         [ -  + ]:         25 :     if (verbose) {
    2106                 :          0 :         PySys_FormatStderr("import _imp # builtin\n");
    2107                 :            :     }
    2108                 :         25 :     PyObject *imp_mod = bootstrap_imp(tstate);
    2109         [ -  + ]:         25 :     if (imp_mod == NULL) {
    2110                 :          0 :         return -1;
    2111                 :            :     }
    2112         [ -  + ]:         25 :     if (_PyImport_SetModuleString("_imp", imp_mod) < 0) {
    2113                 :          0 :         Py_DECREF(imp_mod);
    2114                 :          0 :         return -1;
    2115                 :            :     }
    2116                 :            : 
    2117                 :            :     // Install importlib as the implementation of import
    2118                 :         25 :     PyObject *value = PyObject_CallMethod(importlib, "_install",
    2119                 :            :                                           "OO", sysmod, imp_mod);
    2120                 :         25 :     Py_DECREF(imp_mod);
    2121         [ -  + ]:         25 :     if (value == NULL) {
    2122                 :          0 :         return -1;
    2123                 :            :     }
    2124                 :         25 :     Py_DECREF(value);
    2125                 :            : 
    2126                 :            :     assert(!_PyErr_Occurred(tstate));
    2127                 :         25 :     return 0;
    2128                 :            : }
    2129                 :            : 
    2130                 :            : 
    2131                 :            : static int
    2132                 :         25 : init_importlib_external(PyInterpreterState *interp)
    2133                 :            : {
    2134                 :            :     PyObject *value;
    2135                 :         25 :     value = PyObject_CallMethod(IMPORTLIB(interp),
    2136                 :            :                                 "_install_external_importers", "");
    2137         [ -  + ]:         25 :     if (value == NULL) {
    2138                 :          0 :         return -1;
    2139                 :            :     }
    2140                 :         25 :     Py_DECREF(value);
    2141                 :         25 :     return 0;
    2142                 :            : }
    2143                 :            : 
    2144                 :            : PyObject *
    2145                 :         25 : _PyImport_GetImportlibLoader(PyInterpreterState *interp,
    2146                 :            :                              const char *loader_name)
    2147                 :            : {
    2148                 :         25 :     return PyObject_GetAttrString(IMPORTLIB(interp), loader_name);
    2149                 :            : }
    2150                 :            : 
    2151                 :            : PyObject *
    2152                 :         22 : _PyImport_GetImportlibExternalLoader(PyInterpreterState *interp,
    2153                 :            :                                      const char *loader_name)
    2154                 :            : {
    2155                 :         22 :     PyObject *bootstrap = PyObject_GetAttrString(IMPORTLIB(interp),
    2156                 :            :                                                  "_bootstrap_external");
    2157         [ -  + ]:         22 :     if (bootstrap == NULL) {
    2158                 :          0 :         return NULL;
    2159                 :            :     }
    2160                 :            : 
    2161                 :         22 :     PyObject *loader_type = PyObject_GetAttrString(bootstrap, loader_name);
    2162                 :         22 :     Py_DECREF(bootstrap);
    2163                 :         22 :     return loader_type;
    2164                 :            : }
    2165                 :            : 
    2166                 :            : PyObject *
    2167                 :          0 : _PyImport_BlessMyLoader(PyInterpreterState *interp, PyObject *module_globals)
    2168                 :            : {
    2169                 :          0 :     PyObject *external = PyObject_GetAttrString(IMPORTLIB(interp),
    2170                 :            :                                                 "_bootstrap_external");
    2171         [ #  # ]:          0 :     if (external == NULL) {
    2172                 :          0 :         return NULL;
    2173                 :            :     }
    2174                 :            : 
    2175                 :          0 :     PyObject *loader = PyObject_CallMethod(external, "_bless_my_loader",
    2176                 :            :                                            "O", module_globals, NULL);
    2177                 :          0 :     Py_DECREF(external);
    2178                 :          0 :     return loader;
    2179                 :            : }
    2180                 :            : 
    2181                 :            : PyObject *
    2182                 :          0 : _PyImport_ImportlibModuleRepr(PyInterpreterState *interp, PyObject *m)
    2183                 :            : {
    2184                 :          0 :     return PyObject_CallMethod(IMPORTLIB(interp), "_module_repr", "O", m);
    2185                 :            : }
    2186                 :            : 
    2187                 :            : 
    2188                 :            : /*******************/
    2189                 :            : 
    2190                 :            : /* Return a finder object for a sys.path/pkg.__path__ item 'p',
    2191                 :            :    possibly by fetching it from the path_importer_cache dict. If it
    2192                 :            :    wasn't yet cached, traverse path_hooks until a hook is found
    2193                 :            :    that can handle the path item. Return None if no hook could;
    2194                 :            :    this tells our caller that the path based finder could not find
    2195                 :            :    a finder for this path item. Cache the result in
    2196                 :            :    path_importer_cache. */
    2197                 :            : 
    2198                 :            : static PyObject *
    2199                 :         22 : get_path_importer(PyThreadState *tstate, PyObject *path_importer_cache,
    2200                 :            :                   PyObject *path_hooks, PyObject *p)
    2201                 :            : {
    2202                 :            :     PyObject *importer;
    2203                 :            :     Py_ssize_t j, nhooks;
    2204                 :            : 
    2205                 :            :     /* These conditions are the caller's responsibility: */
    2206                 :            :     assert(PyList_Check(path_hooks));
    2207                 :            :     assert(PyDict_Check(path_importer_cache));
    2208                 :            : 
    2209                 :         22 :     nhooks = PyList_Size(path_hooks);
    2210         [ -  + ]:         22 :     if (nhooks < 0)
    2211                 :          0 :         return NULL; /* Shouldn't happen */
    2212                 :            : 
    2213                 :         22 :     importer = PyDict_GetItemWithError(path_importer_cache, p);
    2214   [ +  -  -  + ]:         22 :     if (importer != NULL || _PyErr_Occurred(tstate)) {
    2215                 :          0 :         return Py_XNewRef(importer);
    2216                 :            :     }
    2217                 :            : 
    2218                 :            :     /* set path_importer_cache[p] to None to avoid recursion */
    2219         [ -  + ]:         22 :     if (PyDict_SetItem(path_importer_cache, p, Py_None) != 0)
    2220                 :          0 :         return NULL;
    2221                 :            : 
    2222         [ +  + ]:         66 :     for (j = 0; j < nhooks; j++) {
    2223                 :         44 :         PyObject *hook = PyList_GetItem(path_hooks, j);
    2224         [ -  + ]:         44 :         if (hook == NULL)
    2225                 :          0 :             return NULL;
    2226                 :         44 :         importer = PyObject_CallOneArg(hook, p);
    2227         [ -  + ]:         44 :         if (importer != NULL)
    2228                 :          0 :             break;
    2229                 :            : 
    2230         [ -  + ]:         44 :         if (!_PyErr_ExceptionMatches(tstate, PyExc_ImportError)) {
    2231                 :          0 :             return NULL;
    2232                 :            :         }
    2233                 :         44 :         _PyErr_Clear(tstate);
    2234                 :            :     }
    2235         [ +  - ]:         22 :     if (importer == NULL) {
    2236                 :         22 :         Py_RETURN_NONE;
    2237                 :            :     }
    2238         [ #  # ]:          0 :     if (PyDict_SetItem(path_importer_cache, p, importer) < 0) {
    2239                 :          0 :         Py_DECREF(importer);
    2240                 :          0 :         return NULL;
    2241                 :            :     }
    2242                 :          0 :     return importer;
    2243                 :            : }
    2244                 :            : 
    2245                 :            : PyObject *
    2246                 :         22 : PyImport_GetImporter(PyObject *path)
    2247                 :            : {
    2248                 :         22 :     PyThreadState *tstate = _PyThreadState_GET();
    2249                 :         22 :     PyObject *path_importer_cache = PySys_GetObject("path_importer_cache");
    2250                 :         22 :     PyObject *path_hooks = PySys_GetObject("path_hooks");
    2251   [ +  -  -  + ]:         22 :     if (path_importer_cache == NULL || path_hooks == NULL) {
    2252                 :          0 :         return NULL;
    2253                 :            :     }
    2254                 :         22 :     return get_path_importer(tstate, path_importer_cache, path_hooks, path);
    2255                 :            : }
    2256                 :            : 
    2257                 :            : 
    2258                 :            : /*********************/
    2259                 :            : /* importing modules */
    2260                 :            : /*********************/
    2261                 :            : 
    2262                 :            : int
    2263                 :         29 : _PyImport_InitDefaultImportFunc(PyInterpreterState *interp)
    2264                 :            : {
    2265                 :            :     // Get the __import__ function
    2266                 :         29 :     PyObject *import_func = _PyDict_GetItemStringWithError(interp->builtins,
    2267                 :            :                                                            "__import__");
    2268         [ -  + ]:         29 :     if (import_func == NULL) {
    2269                 :          0 :         return -1;
    2270                 :            :     }
    2271                 :         29 :     IMPORT_FUNC(interp) = Py_NewRef(import_func);
    2272                 :         29 :     return 0;
    2273                 :            : }
    2274                 :            : 
    2275                 :            : int
    2276                 :       3157 : _PyImport_IsDefaultImportFunc(PyInterpreterState *interp, PyObject *func)
    2277                 :            : {
    2278                 :       3157 :     return func == IMPORT_FUNC(interp);
    2279                 :            : }
    2280                 :            : 
    2281                 :            : 
    2282                 :            : /* Import a module, either built-in, frozen, or external, and return
    2283                 :            :    its module object WITH INCREMENTED REFERENCE COUNT */
    2284                 :            : 
    2285                 :            : PyObject *
    2286                 :        154 : PyImport_ImportModule(const char *name)
    2287                 :            : {
    2288                 :            :     PyObject *pname;
    2289                 :            :     PyObject *result;
    2290                 :            : 
    2291                 :        154 :     pname = PyUnicode_FromString(name);
    2292         [ -  + ]:        154 :     if (pname == NULL)
    2293                 :          0 :         return NULL;
    2294                 :        154 :     result = PyImport_Import(pname);
    2295                 :        154 :     Py_DECREF(pname);
    2296                 :        154 :     return result;
    2297                 :            : }
    2298                 :            : 
    2299                 :            : 
    2300                 :            : /* Import a module without blocking
    2301                 :            :  *
    2302                 :            :  * At first it tries to fetch the module from sys.modules. If the module was
    2303                 :            :  * never loaded before it loads it with PyImport_ImportModule() unless another
    2304                 :            :  * thread holds the import lock. In the latter case the function raises an
    2305                 :            :  * ImportError instead of blocking.
    2306                 :            :  *
    2307                 :            :  * Returns the module object with incremented ref count.
    2308                 :            :  */
    2309                 :            : PyObject *
    2310                 :          0 : PyImport_ImportModuleNoBlock(const char *name)
    2311                 :            : {
    2312                 :          0 :     return PyImport_ImportModule(name);
    2313                 :            : }
    2314                 :            : 
    2315                 :            : 
    2316                 :            : /* Remove importlib frames from the traceback,
    2317                 :            :  * except in Verbose mode. */
    2318                 :            : static void
    2319                 :         44 : remove_importlib_frames(PyThreadState *tstate)
    2320                 :            : {
    2321                 :         44 :     const char *importlib_filename = "<frozen importlib._bootstrap>";
    2322                 :         44 :     const char *external_filename = "<frozen importlib._bootstrap_external>";
    2323                 :         44 :     const char *remove_frames = "_call_with_frames_removed";
    2324                 :         44 :     int always_trim = 0;
    2325                 :         44 :     int in_importlib = 0;
    2326                 :         44 :     PyObject **prev_link, **outer_link = NULL;
    2327                 :         44 :     PyObject *base_tb = NULL;
    2328                 :            : 
    2329                 :            :     /* Synopsis: if it's an ImportError, we trim all importlib chunks
    2330                 :            :        from the traceback. We always trim chunks
    2331                 :            :        which end with a call to "_call_with_frames_removed". */
    2332                 :            : 
    2333                 :         44 :     PyObject *exc = _PyErr_GetRaisedException(tstate);
    2334   [ +  -  -  + ]:         44 :     if (exc == NULL || _PyInterpreterState_GetConfig(tstate->interp)->verbose) {
    2335                 :          0 :         goto done;
    2336                 :            :     }
    2337                 :            : 
    2338         [ +  - ]:         44 :     if (PyType_IsSubtype(Py_TYPE(exc), (PyTypeObject *) PyExc_ImportError)) {
    2339                 :         44 :         always_trim = 1;
    2340                 :            :     }
    2341                 :            : 
    2342                 :            :     assert(PyExceptionInstance_Check(exc));
    2343                 :         44 :     base_tb = PyException_GetTraceback(exc);
    2344                 :         44 :     prev_link = &base_tb;
    2345                 :         44 :     PyObject *tb = base_tb;
    2346         [ +  + ]:        140 :     while (tb != NULL) {
    2347                 :            :         assert(PyTraceBack_Check(tb));
    2348                 :         96 :         PyTracebackObject *traceback = (PyTracebackObject *)tb;
    2349                 :         96 :         PyObject *next = (PyObject *) traceback->tb_next;
    2350                 :         96 :         PyFrameObject *frame = traceback->tb_frame;
    2351                 :         96 :         PyCodeObject *code = PyFrame_GetCode(frame);
    2352                 :            :         int now_in_importlib;
    2353                 :            : 
    2354   [ +  +  +  + ]:        100 :         now_in_importlib = _PyUnicode_EqualToASCIIString(code->co_filename, importlib_filename) ||
    2355                 :          4 :                            _PyUnicode_EqualToASCIIString(code->co_filename, external_filename);
    2356   [ +  +  +  + ]:         96 :         if (now_in_importlib && !in_importlib) {
    2357                 :            :             /* This is the link to this chunk of importlib tracebacks */
    2358                 :         44 :             outer_link = prev_link;
    2359                 :            :         }
    2360                 :         96 :         in_importlib = now_in_importlib;
    2361                 :            : 
    2362   [ +  +  -  + ]:         96 :         if (in_importlib &&
    2363         [ #  # ]:          0 :             (always_trim ||
    2364                 :          0 :              _PyUnicode_EqualToASCIIString(code->co_name, remove_frames))) {
    2365                 :         94 :             Py_XSETREF(*outer_link, Py_XNewRef(next));
    2366                 :         94 :             prev_link = outer_link;
    2367                 :            :         }
    2368                 :            :         else {
    2369                 :          2 :             prev_link = (PyObject **) &traceback->tb_next;
    2370                 :            :         }
    2371                 :         96 :         Py_DECREF(code);
    2372                 :         96 :         tb = next;
    2373                 :            :     }
    2374         [ +  + ]:         44 :     if (base_tb == NULL) {
    2375                 :         42 :         base_tb = Py_None;
    2376                 :         42 :         Py_INCREF(Py_None);
    2377                 :            :     }
    2378                 :         44 :     PyException_SetTraceback(exc, base_tb);
    2379                 :         44 : done:
    2380                 :         44 :     Py_XDECREF(base_tb);
    2381                 :         44 :     _PyErr_SetRaisedException(tstate, exc);
    2382                 :         44 : }
    2383                 :            : 
    2384                 :            : 
    2385                 :            : static PyObject *
    2386                 :        244 : resolve_name(PyThreadState *tstate, PyObject *name, PyObject *globals, int level)
    2387                 :            : {
    2388                 :            :     PyObject *abs_name;
    2389                 :        244 :     PyObject *package = NULL;
    2390                 :            :     PyObject *spec;
    2391                 :            :     Py_ssize_t last_dot;
    2392                 :            :     PyObject *base;
    2393                 :            :     int level_up;
    2394                 :            : 
    2395         [ -  + ]:        244 :     if (globals == NULL) {
    2396                 :          0 :         _PyErr_SetString(tstate, PyExc_KeyError, "'__name__' not in globals");
    2397                 :          0 :         goto error;
    2398                 :            :     }
    2399         [ -  + ]:        244 :     if (!PyDict_Check(globals)) {
    2400                 :          0 :         _PyErr_SetString(tstate, PyExc_TypeError, "globals must be a dict");
    2401                 :          0 :         goto error;
    2402                 :            :     }
    2403                 :        244 :     package = PyDict_GetItemWithError(globals, &_Py_ID(__package__));
    2404         [ -  + ]:        244 :     if (package == Py_None) {
    2405                 :          0 :         package = NULL;
    2406                 :            :     }
    2407   [ -  +  -  - ]:        244 :     else if (package == NULL && _PyErr_Occurred(tstate)) {
    2408                 :          0 :         goto error;
    2409                 :            :     }
    2410                 :        244 :     spec = PyDict_GetItemWithError(globals, &_Py_ID(__spec__));
    2411   [ -  +  -  - ]:        244 :     if (spec == NULL && _PyErr_Occurred(tstate)) {
    2412                 :          0 :         goto error;
    2413                 :            :     }
    2414                 :            : 
    2415         [ +  - ]:        244 :     if (package != NULL) {
    2416                 :        244 :         Py_INCREF(package);
    2417         [ -  + ]:        244 :         if (!PyUnicode_Check(package)) {
    2418                 :          0 :             _PyErr_SetString(tstate, PyExc_TypeError,
    2419                 :            :                              "package must be a string");
    2420                 :          0 :             goto error;
    2421                 :            :         }
    2422   [ +  -  +  - ]:        244 :         else if (spec != NULL && spec != Py_None) {
    2423                 :            :             int equal;
    2424                 :        244 :             PyObject *parent = PyObject_GetAttr(spec, &_Py_ID(parent));
    2425         [ -  + ]:        244 :             if (parent == NULL) {
    2426                 :          0 :                 goto error;
    2427                 :            :             }
    2428                 :            : 
    2429                 :        244 :             equal = PyObject_RichCompareBool(package, parent, Py_EQ);
    2430                 :        244 :             Py_DECREF(parent);
    2431         [ -  + ]:        244 :             if (equal < 0) {
    2432                 :          0 :                 goto error;
    2433                 :            :             }
    2434         [ -  + ]:        244 :             else if (equal == 0) {
    2435         [ #  # ]:          0 :                 if (PyErr_WarnEx(PyExc_DeprecationWarning,
    2436                 :            :                         "__package__ != __spec__.parent", 1) < 0) {
    2437                 :          0 :                     goto error;
    2438                 :            :                 }
    2439                 :            :             }
    2440                 :            :         }
    2441                 :            :     }
    2442   [ #  #  #  # ]:          0 :     else if (spec != NULL && spec != Py_None) {
    2443                 :          0 :         package = PyObject_GetAttr(spec, &_Py_ID(parent));
    2444         [ #  # ]:          0 :         if (package == NULL) {
    2445                 :          0 :             goto error;
    2446                 :            :         }
    2447         [ #  # ]:          0 :         else if (!PyUnicode_Check(package)) {
    2448                 :          0 :             _PyErr_SetString(tstate, PyExc_TypeError,
    2449                 :            :                              "__spec__.parent must be a string");
    2450                 :          0 :             goto error;
    2451                 :            :         }
    2452                 :            :     }
    2453                 :            :     else {
    2454         [ #  # ]:          0 :         if (PyErr_WarnEx(PyExc_ImportWarning,
    2455                 :            :                     "can't resolve package from __spec__ or __package__, "
    2456                 :            :                     "falling back on __name__ and __path__", 1) < 0) {
    2457                 :          0 :             goto error;
    2458                 :            :         }
    2459                 :            : 
    2460                 :          0 :         package = PyDict_GetItemWithError(globals, &_Py_ID(__name__));
    2461         [ #  # ]:          0 :         if (package == NULL) {
    2462         [ #  # ]:          0 :             if (!_PyErr_Occurred(tstate)) {
    2463                 :          0 :                 _PyErr_SetString(tstate, PyExc_KeyError,
    2464                 :            :                                  "'__name__' not in globals");
    2465                 :            :             }
    2466                 :          0 :             goto error;
    2467                 :            :         }
    2468                 :            : 
    2469                 :          0 :         Py_INCREF(package);
    2470         [ #  # ]:          0 :         if (!PyUnicode_Check(package)) {
    2471                 :          0 :             _PyErr_SetString(tstate, PyExc_TypeError,
    2472                 :            :                              "__name__ must be a string");
    2473                 :          0 :             goto error;
    2474                 :            :         }
    2475                 :            : 
    2476                 :          0 :         int haspath = PyDict_Contains(globals, &_Py_ID(__path__));
    2477         [ #  # ]:          0 :         if (haspath < 0) {
    2478                 :          0 :             goto error;
    2479                 :            :         }
    2480         [ #  # ]:          0 :         if (!haspath) {
    2481                 :            :             Py_ssize_t dot;
    2482                 :            : 
    2483         [ #  # ]:          0 :             if (PyUnicode_READY(package) < 0) {
    2484                 :          0 :                 goto error;
    2485                 :            :             }
    2486                 :            : 
    2487                 :          0 :             dot = PyUnicode_FindChar(package, '.',
    2488                 :            :                                         0, PyUnicode_GET_LENGTH(package), -1);
    2489         [ #  # ]:          0 :             if (dot == -2) {
    2490                 :          0 :                 goto error;
    2491                 :            :             }
    2492         [ #  # ]:          0 :             else if (dot == -1) {
    2493                 :          0 :                 goto no_parent_error;
    2494                 :            :             }
    2495                 :          0 :             PyObject *substr = PyUnicode_Substring(package, 0, dot);
    2496         [ #  # ]:          0 :             if (substr == NULL) {
    2497                 :          0 :                 goto error;
    2498                 :            :             }
    2499                 :          0 :             Py_SETREF(package, substr);
    2500                 :            :         }
    2501                 :            :     }
    2502                 :            : 
    2503                 :        244 :     last_dot = PyUnicode_GET_LENGTH(package);
    2504         [ -  + ]:        244 :     if (last_dot == 0) {
    2505                 :          0 :         goto no_parent_error;
    2506                 :            :     }
    2507                 :            : 
    2508         [ -  + ]:        244 :     for (level_up = 1; level_up < level; level_up += 1) {
    2509                 :          0 :         last_dot = PyUnicode_FindChar(package, '.', 0, last_dot, -1);
    2510         [ #  # ]:          0 :         if (last_dot == -2) {
    2511                 :          0 :             goto error;
    2512                 :            :         }
    2513         [ #  # ]:          0 :         else if (last_dot == -1) {
    2514                 :          0 :             _PyErr_SetString(tstate, PyExc_ImportError,
    2515                 :            :                              "attempted relative import beyond top-level "
    2516                 :            :                              "package");
    2517                 :          0 :             goto error;
    2518                 :            :         }
    2519                 :            :     }
    2520                 :            : 
    2521                 :        244 :     base = PyUnicode_Substring(package, 0, last_dot);
    2522                 :        244 :     Py_DECREF(package);
    2523   [ +  -  +  + ]:        244 :     if (base == NULL || PyUnicode_GET_LENGTH(name) == 0) {
    2524                 :        124 :         return base;
    2525                 :            :     }
    2526                 :            : 
    2527                 :        120 :     abs_name = PyUnicode_FromFormat("%U.%U", base, name);
    2528                 :        120 :     Py_DECREF(base);
    2529                 :        120 :     return abs_name;
    2530                 :            : 
    2531                 :          0 :   no_parent_error:
    2532                 :          0 :     _PyErr_SetString(tstate, PyExc_ImportError,
    2533                 :            :                      "attempted relative import "
    2534                 :            :                      "with no known parent package");
    2535                 :            : 
    2536                 :          0 :   error:
    2537                 :          0 :     Py_XDECREF(package);
    2538                 :          0 :     return NULL;
    2539                 :            : }
    2540                 :            : 
    2541                 :            : static PyObject *
    2542                 :        936 : import_find_and_load(PyThreadState *tstate, PyObject *abs_name)
    2543                 :            : {
    2544                 :        936 :     PyObject *mod = NULL;
    2545                 :        936 :     PyInterpreterState *interp = tstate->interp;
    2546                 :        936 :     int import_time = _PyInterpreterState_GetConfig(interp)->import_time;
    2547                 :            : #define import_level FIND_AND_LOAD(interp).import_level
    2548                 :            : #define accumulated FIND_AND_LOAD(interp).accumulated
    2549                 :            : 
    2550                 :        936 :     _PyTime_t t1 = 0, accumulated_copy = accumulated;
    2551                 :            : 
    2552                 :        936 :     PyObject *sys_path = PySys_GetObject("path");
    2553                 :        936 :     PyObject *sys_meta_path = PySys_GetObject("meta_path");
    2554                 :        936 :     PyObject *sys_path_hooks = PySys_GetObject("path_hooks");
    2555   [ +  -  +  -  :        936 :     if (_PySys_Audit(tstate, "import", "OOOOO",
             +  -  -  + ]
    2556                 :            :                      abs_name, Py_None, sys_path ? sys_path : Py_None,
    2557                 :            :                      sys_meta_path ? sys_meta_path : Py_None,
    2558                 :            :                      sys_path_hooks ? sys_path_hooks : Py_None) < 0) {
    2559                 :          0 :         return NULL;
    2560                 :            :     }
    2561                 :            : 
    2562                 :            : 
    2563                 :            :     /* XOptions is initialized after first some imports.
    2564                 :            :      * So we can't have negative cache before completed initialization.
    2565                 :            :      * Anyway, importlib._find_and_load is much slower than
    2566                 :            :      * _PyDict_GetItemIdWithError().
    2567                 :            :      */
    2568         [ -  + ]:        936 :     if (import_time) {
    2569                 :            : #define header FIND_AND_LOAD(interp).header
    2570         [ #  # ]:          0 :         if (header) {
    2571                 :          0 :             fputs("import time: self [us] | cumulative | imported package\n",
    2572                 :            :                   stderr);
    2573                 :          0 :             header = 0;
    2574                 :            :         }
    2575                 :            : #undef header
    2576                 :            : 
    2577                 :          0 :         import_level++;
    2578                 :          0 :         t1 = _PyTime_GetPerfCounter();
    2579                 :          0 :         accumulated = 0;
    2580                 :            :     }
    2581                 :            : 
    2582         [ -  + ]:        936 :     if (PyDTrace_IMPORT_FIND_LOAD_START_ENABLED())
    2583                 :          0 :         PyDTrace_IMPORT_FIND_LOAD_START(PyUnicode_AsUTF8(abs_name));
    2584                 :            : 
    2585                 :        936 :     mod = PyObject_CallMethodObjArgs(IMPORTLIB(interp), &_Py_ID(_find_and_load),
    2586                 :            :                                      abs_name, IMPORT_FUNC(interp), NULL);
    2587                 :            : 
    2588         [ -  + ]:        936 :     if (PyDTrace_IMPORT_FIND_LOAD_DONE_ENABLED())
    2589                 :          0 :         PyDTrace_IMPORT_FIND_LOAD_DONE(PyUnicode_AsUTF8(abs_name),
    2590                 :            :                                        mod != NULL);
    2591                 :            : 
    2592         [ -  + ]:        936 :     if (import_time) {
    2593                 :          0 :         _PyTime_t cum = _PyTime_GetPerfCounter() - t1;
    2594                 :            : 
    2595                 :          0 :         import_level--;
    2596                 :          0 :         fprintf(stderr, "import time: %9ld | %10ld | %*s%s\n",
    2597                 :          0 :                 (long)_PyTime_AsMicroseconds(cum - accumulated, _PyTime_ROUND_CEILING),
    2598                 :          0 :                 (long)_PyTime_AsMicroseconds(cum, _PyTime_ROUND_CEILING),
    2599                 :          0 :                 import_level*2, "", PyUnicode_AsUTF8(abs_name));
    2600                 :            : 
    2601                 :          0 :         accumulated = accumulated_copy + cum;
    2602                 :            :     }
    2603                 :            : 
    2604                 :        936 :     return mod;
    2605                 :            : #undef import_level
    2606                 :            : #undef accumulated
    2607                 :            : }
    2608                 :            : 
    2609                 :            : PyObject *
    2610                 :       4494 : PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
    2611                 :            :                                  PyObject *locals, PyObject *fromlist,
    2612                 :            :                                  int level)
    2613                 :            : {
    2614                 :       4494 :     PyThreadState *tstate = _PyThreadState_GET();
    2615                 :       4494 :     PyObject *abs_name = NULL;
    2616                 :       4494 :     PyObject *final_mod = NULL;
    2617                 :       4494 :     PyObject *mod = NULL;
    2618                 :       4494 :     PyObject *package = NULL;
    2619                 :       4494 :     PyInterpreterState *interp = tstate->interp;
    2620                 :            :     int has_from;
    2621                 :            : 
    2622         [ -  + ]:       4494 :     if (name == NULL) {
    2623                 :          0 :         _PyErr_SetString(tstate, PyExc_ValueError, "Empty module name");
    2624                 :          0 :         goto error;
    2625                 :            :     }
    2626                 :            : 
    2627                 :            :     /* The below code is importlib.__import__() & _gcd_import(), ported to C
    2628                 :            :        for added performance. */
    2629                 :            : 
    2630         [ -  + ]:       4494 :     if (!PyUnicode_Check(name)) {
    2631                 :          0 :         _PyErr_SetString(tstate, PyExc_TypeError,
    2632                 :            :                          "module name must be a string");
    2633                 :          0 :         goto error;
    2634                 :            :     }
    2635         [ -  + ]:       4494 :     if (PyUnicode_READY(name) < 0) {
    2636                 :          0 :         goto error;
    2637                 :            :     }
    2638         [ -  + ]:       4494 :     if (level < 0) {
    2639                 :          0 :         _PyErr_SetString(tstate, PyExc_ValueError, "level must be >= 0");
    2640                 :          0 :         goto error;
    2641                 :            :     }
    2642                 :            : 
    2643         [ +  + ]:       4494 :     if (level > 0) {
    2644                 :        244 :         abs_name = resolve_name(tstate, name, globals, level);
    2645         [ -  + ]:        244 :         if (abs_name == NULL)
    2646                 :          0 :             goto error;
    2647                 :            :     }
    2648                 :            :     else {  /* level == 0 */
    2649         [ -  + ]:       4250 :         if (PyUnicode_GET_LENGTH(name) == 0) {
    2650                 :          0 :             _PyErr_SetString(tstate, PyExc_ValueError, "Empty module name");
    2651                 :          0 :             goto error;
    2652                 :            :         }
    2653                 :       4250 :         abs_name = Py_NewRef(name);
    2654                 :            :     }
    2655                 :            : 
    2656                 :       4494 :     mod = import_get_module(tstate, abs_name);
    2657   [ +  +  -  + ]:       4494 :     if (mod == NULL && _PyErr_Occurred(tstate)) {
    2658                 :          0 :         goto error;
    2659                 :            :     }
    2660                 :            : 
    2661   [ +  +  +  - ]:       4494 :     if (mod != NULL && mod != Py_None) {
    2662         [ -  + ]:       3558 :         if (import_ensure_initialized(tstate->interp, mod, abs_name) < 0) {
    2663                 :          0 :             goto error;
    2664                 :            :         }
    2665                 :            :     }
    2666                 :            :     else {
    2667                 :        936 :         Py_XDECREF(mod);
    2668                 :        936 :         mod = import_find_and_load(tstate, abs_name);
    2669         [ +  + ]:        936 :         if (mod == NULL) {
    2670                 :         44 :             goto error;
    2671                 :            :         }
    2672                 :            :     }
    2673                 :            : 
    2674                 :       4450 :     has_from = 0;
    2675   [ +  +  +  + ]:       4450 :     if (fromlist != NULL && fromlist != Py_None) {
    2676                 :       2112 :         has_from = PyObject_IsTrue(fromlist);
    2677         [ -  + ]:       2112 :         if (has_from < 0)
    2678                 :          0 :             goto error;
    2679                 :            :     }
    2680         [ +  + ]:       4450 :     if (!has_from) {
    2681                 :       3278 :         Py_ssize_t len = PyUnicode_GET_LENGTH(name);
    2682   [ -  +  -  - ]:       3376 :         if (level == 0 || len > 0) {
    2683                 :            :             Py_ssize_t dot;
    2684                 :            : 
    2685                 :       3278 :             dot = PyUnicode_FindChar(name, '.', 0, len, 1);
    2686         [ -  + ]:       3278 :             if (dot == -2) {
    2687                 :          0 :                 goto error;
    2688                 :            :             }
    2689                 :            : 
    2690         [ +  + ]:       3278 :             if (dot == -1) {
    2691                 :            :                 /* No dot in module name, simple exit */
    2692                 :       3180 :                 final_mod = Py_NewRef(mod);
    2693                 :       3180 :                 goto error;
    2694                 :            :             }
    2695                 :            : 
    2696         [ +  - ]:         98 :             if (level == 0) {
    2697                 :         98 :                 PyObject *front = PyUnicode_Substring(name, 0, dot);
    2698         [ -  + ]:         98 :                 if (front == NULL) {
    2699                 :          0 :                     goto error;
    2700                 :            :                 }
    2701                 :            : 
    2702                 :         98 :                 final_mod = PyImport_ImportModuleLevelObject(front, NULL, NULL, NULL, 0);
    2703                 :         98 :                 Py_DECREF(front);
    2704                 :            :             }
    2705                 :            :             else {
    2706                 :          0 :                 Py_ssize_t cut_off = len - dot;
    2707                 :          0 :                 Py_ssize_t abs_name_len = PyUnicode_GET_LENGTH(abs_name);
    2708                 :          0 :                 PyObject *to_return = PyUnicode_Substring(abs_name, 0,
    2709                 :            :                                                         abs_name_len - cut_off);
    2710         [ #  # ]:          0 :                 if (to_return == NULL) {
    2711                 :          0 :                     goto error;
    2712                 :            :                 }
    2713                 :            : 
    2714                 :          0 :                 final_mod = import_get_module(tstate, to_return);
    2715                 :          0 :                 Py_DECREF(to_return);
    2716         [ #  # ]:          0 :                 if (final_mod == NULL) {
    2717         [ #  # ]:          0 :                     if (!_PyErr_Occurred(tstate)) {
    2718                 :          0 :                         _PyErr_Format(tstate, PyExc_KeyError,
    2719                 :            :                                       "%R not in sys.modules as expected",
    2720                 :            :                                       to_return);
    2721                 :            :                     }
    2722                 :          0 :                     goto error;
    2723                 :            :                 }
    2724                 :            :             }
    2725                 :            :         }
    2726                 :            :         else {
    2727                 :          0 :             final_mod = Py_NewRef(mod);
    2728                 :            :         }
    2729                 :            :     }
    2730                 :            :     else {
    2731                 :            :         PyObject *path;
    2732         [ -  + ]:       1172 :         if (_PyObject_LookupAttr(mod, &_Py_ID(__path__), &path) < 0) {
    2733                 :          0 :             goto error;
    2734                 :            :         }
    2735         [ +  + ]:       1172 :         if (path) {
    2736                 :        165 :             Py_DECREF(path);
    2737                 :        165 :             final_mod = PyObject_CallMethodObjArgs(
    2738                 :            :                         IMPORTLIB(interp), &_Py_ID(_handle_fromlist),
    2739                 :            :                         mod, fromlist, IMPORT_FUNC(interp), NULL);
    2740                 :            :         }
    2741                 :            :         else {
    2742                 :       1007 :             final_mod = Py_NewRef(mod);
    2743                 :            :         }
    2744                 :            :     }
    2745                 :            : 
    2746                 :       4494 :   error:
    2747                 :       4494 :     Py_XDECREF(abs_name);
    2748                 :       4494 :     Py_XDECREF(mod);
    2749                 :       4494 :     Py_XDECREF(package);
    2750         [ +  + ]:       4494 :     if (final_mod == NULL) {
    2751                 :         44 :         remove_importlib_frames(tstate);
    2752                 :            :     }
    2753                 :       4494 :     return final_mod;
    2754                 :            : }
    2755                 :            : 
    2756                 :            : PyObject *
    2757                 :        180 : PyImport_ImportModuleLevel(const char *name, PyObject *globals, PyObject *locals,
    2758                 :            :                            PyObject *fromlist, int level)
    2759                 :            : {
    2760                 :            :     PyObject *nameobj, *mod;
    2761                 :        180 :     nameobj = PyUnicode_FromString(name);
    2762         [ -  + ]:        180 :     if (nameobj == NULL)
    2763                 :          0 :         return NULL;
    2764                 :        180 :     mod = PyImport_ImportModuleLevelObject(nameobj, globals, locals,
    2765                 :            :                                            fromlist, level);
    2766                 :        180 :     Py_DECREF(nameobj);
    2767                 :        180 :     return mod;
    2768                 :            : }
    2769                 :            : 
    2770                 :            : 
    2771                 :            : /* Re-import a module of any kind and return its module object, WITH
    2772                 :            :    INCREMENTED REFERENCE COUNT */
    2773                 :            : 
    2774                 :            : PyObject *
    2775                 :          0 : PyImport_ReloadModule(PyObject *m)
    2776                 :            : {
    2777                 :          0 :     PyObject *reloaded_module = NULL;
    2778                 :          0 :     PyObject *importlib = PyImport_GetModule(&_Py_ID(importlib));
    2779         [ #  # ]:          0 :     if (importlib == NULL) {
    2780         [ #  # ]:          0 :         if (PyErr_Occurred()) {
    2781                 :          0 :             return NULL;
    2782                 :            :         }
    2783                 :            : 
    2784                 :          0 :         importlib = PyImport_ImportModule("importlib");
    2785         [ #  # ]:          0 :         if (importlib == NULL) {
    2786                 :          0 :             return NULL;
    2787                 :            :         }
    2788                 :            :     }
    2789                 :            : 
    2790                 :          0 :     reloaded_module = PyObject_CallMethodOneArg(importlib, &_Py_ID(reload), m);
    2791                 :          0 :     Py_DECREF(importlib);
    2792                 :          0 :     return reloaded_module;
    2793                 :            : }
    2794                 :            : 
    2795                 :            : 
    2796                 :            : /* Higher-level import emulator which emulates the "import" statement
    2797                 :            :    more accurately -- it invokes the __import__() function from the
    2798                 :            :    builtins of the current globals.  This means that the import is
    2799                 :            :    done using whatever import hooks are installed in the current
    2800                 :            :    environment.
    2801                 :            :    A dummy list ["__doc__"] is passed as the 4th argument so that
    2802                 :            :    e.g. PyImport_Import(PyUnicode_FromString("win32com.client.gencache"))
    2803                 :            :    will return <module "gencache"> instead of <module "win32com">. */
    2804                 :            : 
    2805                 :            : PyObject *
    2806                 :        940 : PyImport_Import(PyObject *module_name)
    2807                 :            : {
    2808                 :        940 :     PyThreadState *tstate = _PyThreadState_GET();
    2809                 :        940 :     PyObject *globals = NULL;
    2810                 :        940 :     PyObject *import = NULL;
    2811                 :        940 :     PyObject *builtins = NULL;
    2812                 :        940 :     PyObject *r = NULL;
    2813                 :            : 
    2814                 :        940 :     PyObject *from_list = PyList_New(0);
    2815         [ -  + ]:        940 :     if (from_list == NULL) {
    2816                 :          0 :         goto err;
    2817                 :            :     }
    2818                 :            : 
    2819                 :            :     /* Get the builtins from current globals */
    2820                 :        940 :     globals = PyEval_GetGlobals();
    2821         [ +  + ]:        940 :     if (globals != NULL) {
    2822                 :        760 :         Py_INCREF(globals);
    2823                 :        760 :         builtins = PyObject_GetItem(globals, &_Py_ID(__builtins__));
    2824         [ -  + ]:        760 :         if (builtins == NULL)
    2825                 :          0 :             goto err;
    2826                 :            :     }
    2827                 :            :     else {
    2828                 :            :         /* No globals -- use standard builtins, and fake globals */
    2829                 :        180 :         builtins = PyImport_ImportModuleLevel("builtins",
    2830                 :            :                                               NULL, NULL, NULL, 0);
    2831         [ -  + ]:        180 :         if (builtins == NULL) {
    2832                 :          0 :             goto err;
    2833                 :            :         }
    2834                 :        180 :         globals = Py_BuildValue("{OO}", &_Py_ID(__builtins__), builtins);
    2835         [ -  + ]:        180 :         if (globals == NULL)
    2836                 :          0 :             goto err;
    2837                 :            :     }
    2838                 :            : 
    2839                 :            :     /* Get the __import__ function from the builtins */
    2840         [ +  + ]:        940 :     if (PyDict_Check(builtins)) {
    2841                 :        760 :         import = PyObject_GetItem(builtins, &_Py_ID(__import__));
    2842         [ -  + ]:        760 :         if (import == NULL) {
    2843                 :          0 :             _PyErr_SetObject(tstate, PyExc_KeyError, &_Py_ID(__import__));
    2844                 :            :         }
    2845                 :            :     }
    2846                 :            :     else
    2847                 :        180 :         import = PyObject_GetAttr(builtins, &_Py_ID(__import__));
    2848         [ -  + ]:        940 :     if (import == NULL)
    2849                 :          0 :         goto err;
    2850                 :            : 
    2851                 :            :     /* Call the __import__ function with the proper argument list
    2852                 :            :        Always use absolute import here.
    2853                 :            :        Calling for side-effect of import. */
    2854                 :        940 :     r = PyObject_CallFunction(import, "OOOOi", module_name, globals,
    2855                 :            :                               globals, from_list, 0, NULL);
    2856         [ -  + ]:        940 :     if (r == NULL)
    2857                 :          0 :         goto err;
    2858                 :        940 :     Py_DECREF(r);
    2859                 :            : 
    2860                 :        940 :     r = import_get_module(tstate, module_name);
    2861   [ +  -  -  - ]:        940 :     if (r == NULL && !_PyErr_Occurred(tstate)) {
    2862                 :          0 :         _PyErr_SetObject(tstate, PyExc_KeyError, module_name);
    2863                 :            :     }
    2864                 :            : 
    2865                 :        940 :   err:
    2866                 :        940 :     Py_XDECREF(globals);
    2867                 :        940 :     Py_XDECREF(builtins);
    2868                 :        940 :     Py_XDECREF(import);
    2869                 :        940 :     Py_XDECREF(from_list);
    2870                 :            : 
    2871                 :        940 :     return r;
    2872                 :            : }
    2873                 :            : 
    2874                 :            : 
    2875                 :            : /*********************/
    2876                 :            : /* runtime lifecycle */
    2877                 :            : /*********************/
    2878                 :            : 
    2879                 :            : PyStatus
    2880                 :         29 : _PyImport_Init(void)
    2881                 :            : {
    2882         [ -  + ]:         29 :     if (INITTAB != NULL) {
    2883                 :          0 :         return _PyStatus_ERR("global import state already initialized");
    2884                 :            :     }
    2885                 :            : 
    2886                 :         29 :     PyStatus status = _PyStatus_OK();
    2887                 :            : 
    2888                 :            :     /* Force default raw memory allocator to get a known allocator to be able
    2889                 :            :        to release the memory in _PyImport_Fini() */
    2890                 :            :     PyMemAllocatorEx old_alloc;
    2891                 :         29 :     _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
    2892                 :            : 
    2893         [ +  - ]:         29 :     if (init_builtin_modules_table() != 0) {
    2894                 :          0 :         status = PyStatus_NoMemory();
    2895                 :          0 :         goto done;
    2896                 :            :     }
    2897                 :            : 
    2898                 :         29 : done:
    2899                 :         29 :     PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
    2900                 :         29 :     return status;
    2901                 :            : }
    2902                 :            : 
    2903                 :            : void
    2904                 :         25 : _PyImport_Fini(void)
    2905                 :            : {
    2906                 :            :     /* Destroy the database used by _PyImport_{Fixup,Find}Extension */
    2907                 :         25 :     _extensions_cache_clear_all();
    2908                 :            : 
    2909                 :            :     /* Use the same memory allocator as _PyImport_Init(). */
    2910                 :            :     PyMemAllocatorEx old_alloc;
    2911                 :         25 :     _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
    2912                 :            : 
    2913                 :            :     /* Free memory allocated by _PyImport_Init() */
    2914                 :         25 :     fini_builtin_modules_table();
    2915                 :            : 
    2916                 :         25 :     PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
    2917                 :         25 : }
    2918                 :            : 
    2919                 :            : void
    2920                 :         25 : _PyImport_Fini2(void)
    2921                 :            : {
    2922                 :            :     /* Use the same memory allocator than PyImport_ExtendInittab(). */
    2923                 :            :     PyMemAllocatorEx old_alloc;
    2924                 :         25 :     _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
    2925                 :            : 
    2926                 :            :     // Reset PyImport_Inittab
    2927                 :         25 :     PyImport_Inittab = _PyImport_Inittab;
    2928                 :            : 
    2929                 :            :     /* Free memory allocated by PyImport_ExtendInittab() */
    2930                 :         25 :     PyMem_RawFree(inittab_copy);
    2931                 :         25 :     inittab_copy = NULL;
    2932                 :            : 
    2933                 :         25 :     PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
    2934                 :         25 : }
    2935                 :            : 
    2936                 :            : 
    2937                 :            : /*************************/
    2938                 :            : /* interpreter lifecycle */
    2939                 :            : /*************************/
    2940                 :            : 
    2941                 :            : PyStatus
    2942                 :         29 : _PyImport_InitCore(PyThreadState *tstate, PyObject *sysmod, int importlib)
    2943                 :            : {
    2944                 :            :     // XXX Initialize here: interp->modules and interp->import_func.
    2945                 :            :     // XXX Initialize here: sys.modules and sys.meta_path.
    2946                 :            : 
    2947         [ +  + ]:         29 :     if (importlib) {
    2948                 :            :         /* This call sets up builtin and frozen import support */
    2949         [ -  + ]:         25 :         if (init_importlib(tstate, sysmod) < 0) {
    2950                 :          0 :             return _PyStatus_ERR("failed to initialize importlib");
    2951                 :            :         }
    2952                 :            :     }
    2953                 :            : 
    2954                 :         29 :     return _PyStatus_OK();
    2955                 :            : }
    2956                 :            : 
    2957                 :            : /* In some corner cases it is important to be sure that the import
    2958                 :            :    machinery has been initialized (or not cleaned up yet).  For
    2959                 :            :    example, see issue #4236 and PyModule_Create2(). */
    2960                 :            : 
    2961                 :            : int
    2962                 :         46 : _PyImport_IsInitialized(PyInterpreterState *interp)
    2963                 :            : {
    2964         [ -  + ]:         46 :     if (MODULES(interp) == NULL)
    2965                 :          0 :         return 0;
    2966                 :         46 :     return 1;
    2967                 :            : }
    2968                 :            : 
    2969                 :            : /* Clear the direct per-interpreter import state, if not cleared already. */
    2970                 :            : void
    2971                 :         50 : _PyImport_ClearCore(PyInterpreterState *interp)
    2972                 :            : {
    2973                 :            :     /* interp->modules should have been cleaned up and cleared already
    2974                 :            :        by _PyImport_FiniCore(). */
    2975         [ -  + ]:         50 :     Py_CLEAR(MODULES(interp));
    2976         [ +  + ]:         50 :     Py_CLEAR(MODULES_BY_INDEX(interp));
    2977         [ +  + ]:         50 :     Py_CLEAR(IMPORTLIB(interp));
    2978         [ +  + ]:         50 :     Py_CLEAR(IMPORT_FUNC(interp));
    2979                 :         50 : }
    2980                 :            : 
    2981                 :            : void
    2982                 :         25 : _PyImport_FiniCore(PyInterpreterState *interp)
    2983                 :            : {
    2984                 :         25 :     int verbose = _PyInterpreterState_GetConfig(interp)->verbose;
    2985                 :            : 
    2986         [ -  + ]:         25 :     if (_PySys_ClearAttrString(interp, "meta_path", verbose) < 0) {
    2987                 :          0 :         PyErr_WriteUnraisable(NULL);
    2988                 :            :     }
    2989                 :            : 
    2990                 :            :     // XXX Pull in most of finalize_modules() in pylifecycle.c.
    2991                 :            : 
    2992         [ -  + ]:         25 :     if (_PySys_ClearAttrString(interp, "modules", verbose) < 0) {
    2993                 :          0 :         PyErr_WriteUnraisable(NULL);
    2994                 :            :     }
    2995                 :            : 
    2996         [ +  - ]:         25 :     if (IMPORT_LOCK(interp) != NULL) {
    2997                 :         25 :         PyThread_free_lock(IMPORT_LOCK(interp));
    2998                 :         25 :         IMPORT_LOCK(interp) = NULL;
    2999                 :            :     }
    3000                 :            : 
    3001                 :         25 :     _PyImport_ClearCore(interp);
    3002                 :         25 : }
    3003                 :            : 
    3004                 :            : // XXX Add something like _PyImport_Disable() for use early in interp fini?
    3005                 :            : 
    3006                 :            : 
    3007                 :            : /* "external" imports */
    3008                 :            : 
    3009                 :            : static int
    3010                 :         25 : init_zipimport(PyThreadState *tstate, int verbose)
    3011                 :            : {
    3012                 :         25 :     PyObject *path_hooks = PySys_GetObject("path_hooks");
    3013         [ -  + ]:         25 :     if (path_hooks == NULL) {
    3014                 :          0 :         _PyErr_SetString(tstate, PyExc_RuntimeError,
    3015                 :            :                          "unable to get sys.path_hooks");
    3016                 :          0 :         return -1;
    3017                 :            :     }
    3018                 :            : 
    3019         [ -  + ]:         25 :     if (verbose) {
    3020                 :          0 :         PySys_WriteStderr("# installing zipimport hook\n");
    3021                 :            :     }
    3022                 :            : 
    3023                 :         25 :     PyObject *zipimporter = _PyImport_GetModuleAttrString("zipimport", "zipimporter");
    3024         [ -  + ]:         25 :     if (zipimporter == NULL) {
    3025                 :          0 :         _PyErr_Clear(tstate); /* No zipimporter object -- okay */
    3026         [ #  # ]:          0 :         if (verbose) {
    3027                 :          0 :             PySys_WriteStderr("# can't import zipimport.zipimporter\n");
    3028                 :            :         }
    3029                 :            :     }
    3030                 :            :     else {
    3031                 :            :         /* sys.path_hooks.insert(0, zipimporter) */
    3032                 :         25 :         int err = PyList_Insert(path_hooks, 0, zipimporter);
    3033                 :         25 :         Py_DECREF(zipimporter);
    3034         [ -  + ]:         25 :         if (err < 0) {
    3035                 :          0 :             return -1;
    3036                 :            :         }
    3037         [ -  + ]:         25 :         if (verbose) {
    3038                 :          0 :             PySys_WriteStderr("# installed zipimport hook\n");
    3039                 :            :         }
    3040                 :            :     }
    3041                 :            : 
    3042                 :         25 :     return 0;
    3043                 :            : }
    3044                 :            : 
    3045                 :            : PyStatus
    3046                 :         25 : _PyImport_InitExternal(PyThreadState *tstate)
    3047                 :            : {
    3048                 :         25 :     int verbose = _PyInterpreterState_GetConfig(tstate->interp)->verbose;
    3049                 :            : 
    3050                 :            :     // XXX Initialize here: sys.path_hooks and sys.path_importer_cache.
    3051                 :            : 
    3052         [ -  + ]:         25 :     if (init_importlib_external(tstate->interp) != 0) {
    3053                 :          0 :         _PyErr_Print(tstate);
    3054                 :          0 :         return _PyStatus_ERR("external importer setup failed");
    3055                 :            :     }
    3056                 :            : 
    3057         [ -  + ]:         25 :     if (init_zipimport(tstate, verbose) != 0) {
    3058                 :          0 :         PyErr_Print();
    3059                 :          0 :         return _PyStatus_ERR("initializing zipimport failed");
    3060                 :            :     }
    3061                 :            : 
    3062                 :         25 :     return _PyStatus_OK();
    3063                 :            : }
    3064                 :            : 
    3065                 :            : void
    3066                 :         25 : _PyImport_FiniExternal(PyInterpreterState *interp)
    3067                 :            : {
    3068                 :         25 :     int verbose = _PyInterpreterState_GetConfig(interp)->verbose;
    3069                 :            : 
    3070                 :            :     // XXX Uninstall importlib metapath importers here?
    3071                 :            : 
    3072         [ -  + ]:         25 :     if (_PySys_ClearAttrString(interp, "path_importer_cache", verbose) < 0) {
    3073                 :          0 :         PyErr_WriteUnraisable(NULL);
    3074                 :            :     }
    3075         [ -  + ]:         25 :     if (_PySys_ClearAttrString(interp, "path_hooks", verbose) < 0) {
    3076                 :          0 :         PyErr_WriteUnraisable(NULL);
    3077                 :            :     }
    3078                 :         25 : }
    3079                 :            : 
    3080                 :            : 
    3081                 :            : /******************/
    3082                 :            : /* module helpers */
    3083                 :            : /******************/
    3084                 :            : 
    3085                 :            : PyObject *
    3086                 :        786 : _PyImport_GetModuleAttr(PyObject *modname, PyObject *attrname)
    3087                 :            : {
    3088                 :        786 :     PyObject *mod = PyImport_Import(modname);
    3089         [ -  + ]:        786 :     if (mod == NULL) {
    3090                 :          0 :         return NULL;
    3091                 :            :     }
    3092                 :        786 :     PyObject *result = PyObject_GetAttr(mod, attrname);
    3093                 :        786 :     Py_DECREF(mod);
    3094                 :        786 :     return result;
    3095                 :            : }
    3096                 :            : 
    3097                 :            : PyObject *
    3098                 :        786 : _PyImport_GetModuleAttrString(const char *modname, const char *attrname)
    3099                 :            : {
    3100                 :        786 :     PyObject *pmodname = PyUnicode_FromString(modname);
    3101         [ -  + ]:        786 :     if (pmodname == NULL) {
    3102                 :          0 :         return NULL;
    3103                 :            :     }
    3104                 :        786 :     PyObject *pattrname = PyUnicode_FromString(attrname);
    3105         [ -  + ]:        786 :     if (pattrname == NULL) {
    3106                 :          0 :         Py_DECREF(pmodname);
    3107                 :          0 :         return NULL;
    3108                 :            :     }
    3109                 :        786 :     PyObject *result = _PyImport_GetModuleAttr(pmodname, pattrname);
    3110                 :        786 :     Py_DECREF(pattrname);
    3111                 :        786 :     Py_DECREF(pmodname);
    3112                 :        786 :     return result;
    3113                 :            : }
    3114                 :            : 
    3115                 :            : 
    3116                 :            : /**************/
    3117                 :            : /* the module */
    3118                 :            : /**************/
    3119                 :            : 
    3120                 :            : /*[clinic input]
    3121                 :            : _imp.lock_held
    3122                 :            : 
    3123                 :            : Return True if the import lock is currently held, else False.
    3124                 :            : 
    3125                 :            : On platforms without threads, return False.
    3126                 :            : [clinic start generated code]*/
    3127                 :            : 
    3128                 :            : static PyObject *
    3129                 :          0 : _imp_lock_held_impl(PyObject *module)
    3130                 :            : /*[clinic end generated code: output=8b89384b5e1963fc input=9b088f9b217d9bdf]*/
    3131                 :            : {
    3132                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
    3133                 :          0 :     return PyBool_FromLong(
    3134                 :          0 :             IMPORT_LOCK_THREAD(interp) != PYTHREAD_INVALID_THREAD_ID);
    3135                 :            : }
    3136                 :            : 
    3137                 :            : /*[clinic input]
    3138                 :            : _imp.acquire_lock
    3139                 :            : 
    3140                 :            : Acquires the interpreter's import lock for the current thread.
    3141                 :            : 
    3142                 :            : This lock should be used by import hooks to ensure thread-safety when importing
    3143                 :            : modules. On platforms without threads, this function does nothing.
    3144                 :            : [clinic start generated code]*/
    3145                 :            : 
    3146                 :            : static PyObject *
    3147                 :       4609 : _imp_acquire_lock_impl(PyObject *module)
    3148                 :            : /*[clinic end generated code: output=1aff58cb0ee1b026 input=4a2d4381866d5fdc]*/
    3149                 :            : {
    3150                 :       4609 :     PyInterpreterState *interp = _PyInterpreterState_GET();
    3151                 :       4609 :     _PyImport_AcquireLock(interp);
    3152                 :       4609 :     Py_RETURN_NONE;
    3153                 :            : }
    3154                 :            : 
    3155                 :            : /*[clinic input]
    3156                 :            : _imp.release_lock
    3157                 :            : 
    3158                 :            : Release the interpreter's import lock.
    3159                 :            : 
    3160                 :            : On platforms without threads, this function does nothing.
    3161                 :            : [clinic start generated code]*/
    3162                 :            : 
    3163                 :            : static PyObject *
    3164                 :       4609 : _imp_release_lock_impl(PyObject *module)
    3165                 :            : /*[clinic end generated code: output=7faab6d0be178b0a input=934fb11516dd778b]*/
    3166                 :            : {
    3167                 :       4609 :     PyInterpreterState *interp = _PyInterpreterState_GET();
    3168         [ -  + ]:       4609 :     if (_PyImport_ReleaseLock(interp) < 0) {
    3169                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
    3170                 :            :                         "not holding the import lock");
    3171                 :          0 :         return NULL;
    3172                 :            :     }
    3173                 :       4609 :     Py_RETURN_NONE;
    3174                 :            : }
    3175                 :            : 
    3176                 :            : 
    3177                 :            : /*[clinic input]
    3178                 :            : _imp._fix_co_filename
    3179                 :            : 
    3180                 :            :     code: object(type="PyCodeObject *", subclass_of="&PyCode_Type")
    3181                 :            :         Code object to change.
    3182                 :            : 
    3183                 :            :     path: unicode
    3184                 :            :         File path to use.
    3185                 :            :     /
    3186                 :            : 
    3187                 :            : Changes code.co_filename to specify the passed-in file path.
    3188                 :            : [clinic start generated code]*/
    3189                 :            : 
    3190                 :            : static PyObject *
    3191                 :        386 : _imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,
    3192                 :            :                            PyObject *path)
    3193                 :            : /*[clinic end generated code: output=1d002f100235587d input=895ba50e78b82f05]*/
    3194                 :            : 
    3195                 :            : {
    3196                 :        386 :     update_compiled_module(code, path);
    3197                 :            : 
    3198                 :        386 :     Py_RETURN_NONE;
    3199                 :            : }
    3200                 :            : 
    3201                 :            : 
    3202                 :            : /*[clinic input]
    3203                 :            : _imp.create_builtin
    3204                 :            : 
    3205                 :            :     spec: object
    3206                 :            :     /
    3207                 :            : 
    3208                 :            : Create an extension module.
    3209                 :            : [clinic start generated code]*/
    3210                 :            : 
    3211                 :            : static PyObject *
    3212                 :        323 : _imp_create_builtin(PyObject *module, PyObject *spec)
    3213                 :            : /*[clinic end generated code: output=ace7ff22271e6f39 input=37f966f890384e47]*/
    3214                 :            : {
    3215                 :        323 :     PyThreadState *tstate = _PyThreadState_GET();
    3216                 :            : 
    3217                 :        323 :     PyObject *name = PyObject_GetAttrString(spec, "name");
    3218         [ -  + ]:        323 :     if (name == NULL) {
    3219                 :          0 :         return NULL;
    3220                 :            :     }
    3221                 :            : 
    3222         [ -  + ]:        323 :     if (!PyUnicode_Check(name)) {
    3223                 :          0 :         PyErr_Format(PyExc_TypeError,
    3224                 :            :                      "name must be string, not %.200s",
    3225                 :          0 :                      Py_TYPE(name)->tp_name);
    3226                 :          0 :         Py_DECREF(name);
    3227                 :          0 :         return NULL;
    3228                 :            :     }
    3229                 :            : 
    3230                 :        323 :     PyObject *mod = create_builtin(tstate, name, spec);
    3231                 :        323 :     Py_DECREF(name);
    3232                 :        323 :     return mod;
    3233                 :            : }
    3234                 :            : 
    3235                 :            : 
    3236                 :            : /*[clinic input]
    3237                 :            : _imp.extension_suffixes
    3238                 :            : 
    3239                 :            : Returns the list of file suffixes used to identify extension modules.
    3240                 :            : [clinic start generated code]*/
    3241                 :            : 
    3242                 :            : static PyObject *
    3243                 :         50 : _imp_extension_suffixes_impl(PyObject *module)
    3244                 :            : /*[clinic end generated code: output=0bf346e25a8f0cd3 input=ecdeeecfcb6f839e]*/
    3245                 :            : {
    3246                 :            :     PyObject *list;
    3247                 :            : 
    3248                 :         50 :     list = PyList_New(0);
    3249         [ -  + ]:         50 :     if (list == NULL)
    3250                 :          0 :         return NULL;
    3251                 :            : #ifdef HAVE_DYNAMIC_LOADING
    3252                 :            :     const char *suffix;
    3253                 :         50 :     unsigned int index = 0;
    3254                 :            : 
    3255         [ +  + ]:        200 :     while ((suffix = _PyImport_DynLoadFiletab[index])) {
    3256                 :        150 :         PyObject *item = PyUnicode_FromString(suffix);
    3257         [ -  + ]:        150 :         if (item == NULL) {
    3258                 :          0 :             Py_DECREF(list);
    3259                 :          0 :             return NULL;
    3260                 :            :         }
    3261         [ -  + ]:        150 :         if (PyList_Append(list, item) < 0) {
    3262                 :          0 :             Py_DECREF(list);
    3263                 :          0 :             Py_DECREF(item);
    3264                 :          0 :             return NULL;
    3265                 :            :         }
    3266                 :        150 :         Py_DECREF(item);
    3267                 :        150 :         index += 1;
    3268                 :            :     }
    3269                 :            : #endif
    3270                 :         50 :     return list;
    3271                 :            : }
    3272                 :            : 
    3273                 :            : /*[clinic input]
    3274                 :            : _imp.init_frozen
    3275                 :            : 
    3276                 :            :     name: unicode
    3277                 :            :     /
    3278                 :            : 
    3279                 :            : Initializes a frozen module.
    3280                 :            : [clinic start generated code]*/
    3281                 :            : 
    3282                 :            : static PyObject *
    3283                 :          0 : _imp_init_frozen_impl(PyObject *module, PyObject *name)
    3284                 :            : /*[clinic end generated code: output=fc0511ed869fd69c input=13019adfc04f3fb3]*/
    3285                 :            : {
    3286                 :          0 :     PyThreadState *tstate = _PyThreadState_GET();
    3287                 :            :     int ret;
    3288                 :            : 
    3289                 :          0 :     ret = PyImport_ImportFrozenModuleObject(name);
    3290         [ #  # ]:          0 :     if (ret < 0)
    3291                 :          0 :         return NULL;
    3292         [ #  # ]:          0 :     if (ret == 0) {
    3293                 :          0 :         Py_RETURN_NONE;
    3294                 :            :     }
    3295                 :          0 :     return import_add_module(tstate, name);
    3296                 :            : }
    3297                 :            : 
    3298                 :            : /*[clinic input]
    3299                 :            : _imp.find_frozen
    3300                 :            : 
    3301                 :            :     name: unicode
    3302                 :            :     /
    3303                 :            :     *
    3304                 :            :     withdata: bool = False
    3305                 :            : 
    3306                 :            : Return info about the corresponding frozen module (if there is one) or None.
    3307                 :            : 
    3308                 :            : The returned info (a 2-tuple):
    3309                 :            : 
    3310                 :            :  * data         the raw marshalled bytes
    3311                 :            :  * is_package   whether or not it is a package
    3312                 :            :  * origname     the originally frozen module's name, or None if not
    3313                 :            :                 a stdlib module (this will usually be the same as
    3314                 :            :                 the module's current name)
    3315                 :            : [clinic start generated code]*/
    3316                 :            : 
    3317                 :            : static PyObject *
    3318                 :        720 : _imp_find_frozen_impl(PyObject *module, PyObject *name, int withdata)
    3319                 :            : /*[clinic end generated code: output=8c1c3c7f925397a5 input=22a8847c201542fd]*/
    3320                 :            : {
    3321                 :            :     struct frozen_info info;
    3322                 :        720 :     frozen_status status = find_frozen(name, &info);
    3323   [ +  +  -  + ]:        720 :     if (status == FROZEN_NOT_FOUND || status == FROZEN_DISABLED) {
    3324                 :        623 :         Py_RETURN_NONE;
    3325                 :            :     }
    3326         [ -  + ]:         97 :     else if (status == FROZEN_BAD_NAME) {
    3327                 :          0 :         Py_RETURN_NONE;
    3328                 :            :     }
    3329         [ -  + ]:         97 :     else if (status != FROZEN_OKAY) {
    3330                 :          0 :         set_frozen_error(status, name);
    3331                 :          0 :         return NULL;
    3332                 :            :     }
    3333                 :            : 
    3334                 :         97 :     PyObject *data = NULL;
    3335         [ -  + ]:         97 :     if (withdata) {
    3336                 :          0 :         data = PyMemoryView_FromMemory((char *)info.data, info.size, PyBUF_READ);
    3337         [ #  # ]:          0 :         if (data == NULL) {
    3338                 :          0 :             return NULL;
    3339                 :            :         }
    3340                 :            :     }
    3341                 :            : 
    3342                 :         97 :     PyObject *origname = NULL;
    3343   [ +  -  +  - ]:         97 :     if (info.origname != NULL && info.origname[0] != '\0') {
    3344                 :         97 :         origname = PyUnicode_FromString(info.origname);
    3345         [ -  + ]:         97 :         if (origname == NULL) {
    3346                 :          0 :             Py_DECREF(data);
    3347                 :          0 :             return NULL;
    3348                 :            :         }
    3349                 :            :     }
    3350                 :            : 
    3351   [ +  -  -  + ]:        194 :     PyObject *result = PyTuple_Pack(3, data ? data : Py_None,
    3352         [ -  + ]:         97 :                                     info.is_package ? Py_True : Py_False,
    3353                 :            :                                     origname ? origname : Py_None);
    3354                 :         97 :     Py_XDECREF(origname);
    3355                 :         97 :     Py_XDECREF(data);
    3356                 :         97 :     return result;
    3357                 :            : }
    3358                 :            : 
    3359                 :            : /*[clinic input]
    3360                 :            : _imp.get_frozen_object
    3361                 :            : 
    3362                 :            :     name: unicode
    3363                 :            :     data as dataobj: object = None
    3364                 :            :     /
    3365                 :            : 
    3366                 :            : Create a code object for a frozen module.
    3367                 :            : [clinic start generated code]*/
    3368                 :            : 
    3369                 :            : static PyObject *
    3370                 :         97 : _imp_get_frozen_object_impl(PyObject *module, PyObject *name,
    3371                 :            :                             PyObject *dataobj)
    3372                 :            : /*[clinic end generated code: output=54368a673a35e745 input=034bdb88f6460b7b]*/
    3373                 :            : {
    3374                 :         97 :     struct frozen_info info = {0};
    3375                 :         97 :     Py_buffer buf = {0};
    3376         [ -  + ]:         97 :     if (PyObject_CheckBuffer(dataobj)) {
    3377         [ #  # ]:          0 :         if (PyObject_GetBuffer(dataobj, &buf, PyBUF_READ) != 0) {
    3378                 :          0 :             return NULL;
    3379                 :            :         }
    3380                 :          0 :         info.data = (const char *)buf.buf;
    3381                 :          0 :         info.size = buf.len;
    3382                 :            :     }
    3383         [ -  + ]:         97 :     else if (dataobj != Py_None) {
    3384                 :          0 :         _PyArg_BadArgument("get_frozen_object", "argument 2", "bytes", dataobj);
    3385                 :          0 :         return NULL;
    3386                 :            :     }
    3387                 :            :     else {
    3388                 :         97 :         frozen_status status = find_frozen(name, &info);
    3389         [ -  + ]:         97 :         if (status != FROZEN_OKAY) {
    3390                 :          0 :             set_frozen_error(status, name);
    3391                 :          0 :             return NULL;
    3392                 :            :         }
    3393                 :            :     }
    3394                 :            : 
    3395         [ -  + ]:         97 :     if (info.nameobj == NULL) {
    3396                 :          0 :         info.nameobj = name;
    3397                 :            :     }
    3398   [ +  +  -  + ]:         97 :     if (info.size == 0 && info.get_code == NULL) {
    3399                 :            :         /* Does not contain executable code. */
    3400                 :          0 :         set_frozen_error(FROZEN_INVALID, name);
    3401                 :          0 :         return NULL;
    3402                 :            :     }
    3403                 :            : 
    3404                 :         97 :     PyObject *codeobj = unmarshal_frozen_code(&info);
    3405         [ -  + ]:         97 :     if (dataobj != Py_None) {
    3406                 :          0 :         PyBuffer_Release(&buf);
    3407                 :            :     }
    3408                 :         97 :     return codeobj;
    3409                 :            : }
    3410                 :            : 
    3411                 :            : /*[clinic input]
    3412                 :            : _imp.is_frozen_package
    3413                 :            : 
    3414                 :            :     name: unicode
    3415                 :            :     /
    3416                 :            : 
    3417                 :            : Returns True if the module name is of a frozen package.
    3418                 :            : [clinic start generated code]*/
    3419                 :            : 
    3420                 :            : static PyObject *
    3421                 :         25 : _imp_is_frozen_package_impl(PyObject *module, PyObject *name)
    3422                 :            : /*[clinic end generated code: output=e70cbdb45784a1c9 input=81b6cdecd080fbb8]*/
    3423                 :            : {
    3424                 :            :     struct frozen_info info;
    3425                 :         25 :     frozen_status status = find_frozen(name, &info);
    3426   [ -  +  -  - ]:         25 :     if (status != FROZEN_OKAY && status != FROZEN_EXCLUDED) {
    3427                 :          0 :         set_frozen_error(status, name);
    3428                 :          0 :         return NULL;
    3429                 :            :     }
    3430                 :         25 :     return PyBool_FromLong(info.is_package);
    3431                 :            : }
    3432                 :            : 
    3433                 :            : /*[clinic input]
    3434                 :            : _imp.is_builtin
    3435                 :            : 
    3436                 :            :     name: unicode
    3437                 :            :     /
    3438                 :            : 
    3439                 :            : Returns True if the module name corresponds to a built-in module.
    3440                 :            : [clinic start generated code]*/
    3441                 :            : 
    3442                 :            : static PyObject *
    3443                 :        875 : _imp_is_builtin_impl(PyObject *module, PyObject *name)
    3444                 :            : /*[clinic end generated code: output=3bfd1162e2d3be82 input=86befdac021dd1c7]*/
    3445                 :            : {
    3446                 :        875 :     return PyLong_FromLong(is_builtin(name));
    3447                 :            : }
    3448                 :            : 
    3449                 :            : /*[clinic input]
    3450                 :            : _imp.is_frozen
    3451                 :            : 
    3452                 :            :     name: unicode
    3453                 :            :     /
    3454                 :            : 
    3455                 :            : Returns True if the module name corresponds to a frozen module.
    3456                 :            : [clinic start generated code]*/
    3457                 :            : 
    3458                 :            : static PyObject *
    3459                 :         25 : _imp_is_frozen_impl(PyObject *module, PyObject *name)
    3460                 :            : /*[clinic end generated code: output=01f408f5ec0f2577 input=7301dbca1897d66b]*/
    3461                 :            : {
    3462                 :            :     struct frozen_info info;
    3463                 :         25 :     frozen_status status = find_frozen(name, &info);
    3464         [ -  + ]:         25 :     if (status != FROZEN_OKAY) {
    3465                 :          0 :         Py_RETURN_FALSE;
    3466                 :            :     }
    3467                 :         25 :     Py_RETURN_TRUE;
    3468                 :            : }
    3469                 :            : 
    3470                 :            : /*[clinic input]
    3471                 :            : _imp._frozen_module_names
    3472                 :            : 
    3473                 :            : Returns the list of available frozen modules.
    3474                 :            : [clinic start generated code]*/
    3475                 :            : 
    3476                 :            : static PyObject *
    3477                 :          0 : _imp__frozen_module_names_impl(PyObject *module)
    3478                 :            : /*[clinic end generated code: output=80609ef6256310a8 input=76237fbfa94460d2]*/
    3479                 :            : {
    3480                 :          0 :     return list_frozen_module_names();
    3481                 :            : }
    3482                 :            : 
    3483                 :            : /*[clinic input]
    3484                 :            : _imp._override_frozen_modules_for_tests
    3485                 :            : 
    3486                 :            :     override: int
    3487                 :            :     /
    3488                 :            : 
    3489                 :            : (internal-only) Override PyConfig.use_frozen_modules.
    3490                 :            : 
    3491                 :            : (-1: "off", 1: "on", 0: no override)
    3492                 :            : See frozen_modules() in Lib/test/support/import_helper.py.
    3493                 :            : [clinic start generated code]*/
    3494                 :            : 
    3495                 :            : static PyObject *
    3496                 :          0 : _imp__override_frozen_modules_for_tests_impl(PyObject *module, int override)
    3497                 :            : /*[clinic end generated code: output=36d5cb1594160811 input=8f1f95a3ef21aec3]*/
    3498                 :            : {
    3499                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
    3500                 :          0 :     OVERRIDE_FROZEN_MODULES(interp) = override;
    3501                 :          0 :     Py_RETURN_NONE;
    3502                 :            : }
    3503                 :            : 
    3504                 :            : /*[clinic input]
    3505                 :            : _imp._override_multi_interp_extensions_check
    3506                 :            : 
    3507                 :            :     override: int
    3508                 :            :     /
    3509                 :            : 
    3510                 :            : (internal-only) Override PyInterpreterConfig.check_multi_interp_extensions.
    3511                 :            : 
    3512                 :            : (-1: "never", 1: "always", 0: no override)
    3513                 :            : [clinic start generated code]*/
    3514                 :            : 
    3515                 :            : static PyObject *
    3516                 :          0 : _imp__override_multi_interp_extensions_check_impl(PyObject *module,
    3517                 :            :                                                   int override)
    3518                 :            : /*[clinic end generated code: output=3ff043af52bbf280 input=e086a2ea181f92ae]*/
    3519                 :            : {
    3520                 :          0 :     PyInterpreterState *interp = _PyInterpreterState_GET();
    3521         [ #  # ]:          0 :     if (_Py_IsMainInterpreter(interp)) {
    3522                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
    3523                 :            :                         "_imp._override_multi_interp_extensions_check() "
    3524                 :            :                         "cannot be used in the main interpreter");
    3525                 :          0 :         return NULL;
    3526                 :            :     }
    3527                 :          0 :     int oldvalue = OVERRIDE_MULTI_INTERP_EXTENSIONS_CHECK(interp);
    3528                 :          0 :     OVERRIDE_MULTI_INTERP_EXTENSIONS_CHECK(interp) = override;
    3529                 :          0 :     return PyLong_FromLong(oldvalue);
    3530                 :            : }
    3531                 :            : 
    3532                 :            : #ifdef HAVE_DYNAMIC_LOADING
    3533                 :            : 
    3534                 :            : /*[clinic input]
    3535                 :            : _imp.create_dynamic
    3536                 :            : 
    3537                 :            :     spec: object
    3538                 :            :     file: object = NULL
    3539                 :            :     /
    3540                 :            : 
    3541                 :            : Create an extension module.
    3542                 :            : [clinic start generated code]*/
    3543                 :            : 
    3544                 :            : static PyObject *
    3545                 :        115 : _imp_create_dynamic_impl(PyObject *module, PyObject *spec, PyObject *file)
    3546                 :            : /*[clinic end generated code: output=83249b827a4fde77 input=c31b954f4cf4e09d]*/
    3547                 :            : {
    3548                 :            :     PyObject *mod, *name, *path;
    3549                 :            :     FILE *fp;
    3550                 :            : 
    3551                 :        115 :     name = PyObject_GetAttrString(spec, "name");
    3552         [ -  + ]:        115 :     if (name == NULL) {
    3553                 :          0 :         return NULL;
    3554                 :            :     }
    3555                 :            : 
    3556                 :        115 :     path = PyObject_GetAttrString(spec, "origin");
    3557         [ -  + ]:        115 :     if (path == NULL) {
    3558                 :          0 :         Py_DECREF(name);
    3559                 :          0 :         return NULL;
    3560                 :            :     }
    3561                 :            : 
    3562                 :        115 :     PyThreadState *tstate = _PyThreadState_GET();
    3563                 :        115 :     mod = import_find_extension(tstate, name, path);
    3564         [ +  + ]:        115 :     if (mod != NULL) {
    3565                 :          1 :         const char *name_buf = PyUnicode_AsUTF8(name);
    3566                 :            :         assert(name_buf != NULL);
    3567         [ -  + ]:          1 :         if (_PyImport_CheckSubinterpIncompatibleExtensionAllowed(name_buf) < 0) {
    3568                 :          0 :             Py_DECREF(mod);
    3569                 :          0 :             mod = NULL;
    3570                 :            :         }
    3571                 :          1 :         goto finally;
    3572                 :            :     }
    3573         [ -  + ]:        114 :     else if (PyErr_Occurred()) {
    3574                 :          0 :         goto finally;
    3575                 :            :     }
    3576                 :            : 
    3577         [ -  + ]:        114 :     if (file != NULL) {
    3578                 :          0 :         fp = _Py_fopen_obj(path, "r");
    3579         [ #  # ]:          0 :         if (fp == NULL) {
    3580                 :          0 :             goto finally;
    3581                 :            :         }
    3582                 :            :     }
    3583                 :            :     else
    3584                 :        114 :         fp = NULL;
    3585                 :            : 
    3586                 :        114 :     mod = _PyImport_LoadDynamicModuleWithSpec(spec, fp);
    3587                 :            : 
    3588         [ +  - ]:        114 :     if (fp)
    3589                 :          0 :         fclose(fp);
    3590                 :            : 
    3591                 :        114 : finally:
    3592                 :        115 :     Py_DECREF(name);
    3593                 :        115 :     Py_DECREF(path);
    3594                 :        115 :     return mod;
    3595                 :            : }
    3596                 :            : 
    3597                 :            : /*[clinic input]
    3598                 :            : _imp.exec_dynamic -> int
    3599                 :            : 
    3600                 :            :     mod: object
    3601                 :            :     /
    3602                 :            : 
    3603                 :            : Initialize an extension module.
    3604                 :            : [clinic start generated code]*/
    3605                 :            : 
    3606                 :            : static int
    3607                 :        115 : _imp_exec_dynamic_impl(PyObject *module, PyObject *mod)
    3608                 :            : /*[clinic end generated code: output=f5720ac7b465877d input=9fdbfcb250280d3a]*/
    3609                 :            : {
    3610                 :        115 :     return exec_builtin_or_dynamic(mod);
    3611                 :            : }
    3612                 :            : 
    3613                 :            : 
    3614                 :            : #endif /* HAVE_DYNAMIC_LOADING */
    3615                 :            : 
    3616                 :            : /*[clinic input]
    3617                 :            : _imp.exec_builtin -> int
    3618                 :            : 
    3619                 :            :     mod: object
    3620                 :            :     /
    3621                 :            : 
    3622                 :            : Initialize a built-in module.
    3623                 :            : [clinic start generated code]*/
    3624                 :            : 
    3625                 :            : static int
    3626                 :        323 : _imp_exec_builtin_impl(PyObject *module, PyObject *mod)
    3627                 :            : /*[clinic end generated code: output=0262447b240c038e input=7beed5a2f12a60ca]*/
    3628                 :            : {
    3629                 :        323 :     return exec_builtin_or_dynamic(mod);
    3630                 :            : }
    3631                 :            : 
    3632                 :            : /*[clinic input]
    3633                 :            : _imp.source_hash
    3634                 :            : 
    3635                 :            :     key: long
    3636                 :            :     source: Py_buffer
    3637                 :            : [clinic start generated code]*/
    3638                 :            : 
    3639                 :            : static PyObject *
    3640                 :          0 : _imp_source_hash_impl(PyObject *module, long key, Py_buffer *source)
    3641                 :            : /*[clinic end generated code: output=edb292448cf399ea input=9aaad1e590089789]*/
    3642                 :            : {
    3643                 :            :     union {
    3644                 :            :         uint64_t x;
    3645                 :            :         char data[sizeof(uint64_t)];
    3646                 :            :     } hash;
    3647                 :          0 :     hash.x = _Py_KeyedHash((uint64_t)key, source->buf, source->len);
    3648                 :            : #if !PY_LITTLE_ENDIAN
    3649                 :            :     // Force to little-endian. There really ought to be a succinct standard way
    3650                 :            :     // to do this.
    3651                 :            :     for (size_t i = 0; i < sizeof(hash.data)/2; i++) {
    3652                 :            :         char tmp = hash.data[i];
    3653                 :            :         hash.data[i] = hash.data[sizeof(hash.data) - i - 1];
    3654                 :            :         hash.data[sizeof(hash.data) - i - 1] = tmp;
    3655                 :            :     }
    3656                 :            : #endif
    3657                 :          0 :     return PyBytes_FromStringAndSize(hash.data, sizeof(hash.data));
    3658                 :            : }
    3659                 :            : 
    3660                 :            : 
    3661                 :            : PyDoc_STRVAR(doc_imp,
    3662                 :            : "(Extremely) low-level import machinery bits as used by importlib and imp.");
    3663                 :            : 
    3664                 :            : static PyMethodDef imp_methods[] = {
    3665                 :            :     _IMP_EXTENSION_SUFFIXES_METHODDEF
    3666                 :            :     _IMP_LOCK_HELD_METHODDEF
    3667                 :            :     _IMP_ACQUIRE_LOCK_METHODDEF
    3668                 :            :     _IMP_RELEASE_LOCK_METHODDEF
    3669                 :            :     _IMP_FIND_FROZEN_METHODDEF
    3670                 :            :     _IMP_GET_FROZEN_OBJECT_METHODDEF
    3671                 :            :     _IMP_IS_FROZEN_PACKAGE_METHODDEF
    3672                 :            :     _IMP_CREATE_BUILTIN_METHODDEF
    3673                 :            :     _IMP_INIT_FROZEN_METHODDEF
    3674                 :            :     _IMP_IS_BUILTIN_METHODDEF
    3675                 :            :     _IMP_IS_FROZEN_METHODDEF
    3676                 :            :     _IMP__FROZEN_MODULE_NAMES_METHODDEF
    3677                 :            :     _IMP__OVERRIDE_FROZEN_MODULES_FOR_TESTS_METHODDEF
    3678                 :            :     _IMP__OVERRIDE_MULTI_INTERP_EXTENSIONS_CHECK_METHODDEF
    3679                 :            :     _IMP_CREATE_DYNAMIC_METHODDEF
    3680                 :            :     _IMP_EXEC_DYNAMIC_METHODDEF
    3681                 :            :     _IMP_EXEC_BUILTIN_METHODDEF
    3682                 :            :     _IMP__FIX_CO_FILENAME_METHODDEF
    3683                 :            :     _IMP_SOURCE_HASH_METHODDEF
    3684                 :            :     {NULL, NULL}  /* sentinel */
    3685                 :            : };
    3686                 :            : 
    3687                 :            : 
    3688                 :            : static int
    3689                 :         26 : imp_module_exec(PyObject *module)
    3690                 :            : {
    3691                 :         26 :     const wchar_t *mode = _Py_GetConfig()->check_hash_pycs_mode;
    3692                 :         26 :     PyObject *pyc_mode = PyUnicode_FromWideChar(mode, -1);
    3693         [ -  + ]:         26 :     if (pyc_mode == NULL) {
    3694                 :          0 :         return -1;
    3695                 :            :     }
    3696         [ -  + ]:         26 :     if (PyModule_AddObjectRef(module, "check_hash_based_pycs", pyc_mode) < 0) {
    3697                 :          0 :         Py_DECREF(pyc_mode);
    3698                 :          0 :         return -1;
    3699                 :            :     }
    3700                 :         26 :     Py_DECREF(pyc_mode);
    3701                 :            : 
    3702                 :         26 :     return 0;
    3703                 :            : }
    3704                 :            : 
    3705                 :            : 
    3706                 :            : static PyModuleDef_Slot imp_slots[] = {
    3707                 :            :     {Py_mod_exec, imp_module_exec},
    3708                 :            :     {0, NULL}
    3709                 :            : };
    3710                 :            : 
    3711                 :            : static struct PyModuleDef imp_module = {
    3712                 :            :     PyModuleDef_HEAD_INIT,
    3713                 :            :     .m_name = "_imp",
    3714                 :            :     .m_doc = doc_imp,
    3715                 :            :     .m_size = 0,
    3716                 :            :     .m_methods = imp_methods,
    3717                 :            :     .m_slots = imp_slots,
    3718                 :            : };
    3719                 :            : 
    3720                 :            : PyMODINIT_FUNC
    3721                 :         26 : PyInit__imp(void)
    3722                 :            : {
    3723                 :         26 :     return PyModuleDef_Init(&imp_module);
    3724                 :            : }
    3725                 :            : 
    3726                 :            : 
    3727                 :            : #ifdef __cplusplus
    3728                 :            : }
    3729                 :            : #endif

Generated by: LCOV version 1.14