python_packaging/src/external/pybind/include/pybind11/detail/internals.h

   1 /*
   2     pybind11/detail/internals.h: Internal data structure and related functions
   3
   4     Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
   5
   6     All rights reserved. Use of this source code is governed by a
   7     BSD-style license that can be found in the LICENSE file.
   8 */
   9
  10 #pragma once
  11
  12 #include "../pytypes.h"
  13
  14 NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  15 NAMESPACE_BEGIN(detail)
  16 // Forward declarations
  17 inline PyTypeObject *make_static_property_type();
  18 inline PyTypeObject *make_default_metaclass();
  19 inline PyObject *make_object_base_type(PyTypeObject *metaclass);
  20
  21 // The old Python Thread Local Storage (TLS) API is deprecated in Python 3.7 in favor of the new
  22 // Thread Specific Storage (TSS) API.
  23 #if PY_VERSION_HEX >= 0x03070000
  24 #    define PYBIND11_TLS_KEY_INIT(var) Py_tss_t *var = nullptr
  25 #    define PYBIND11_TLS_GET_VALUE(key) PyThread_tss_get((key))
  26 #    define PYBIND11_TLS_REPLACE_VALUE(key, value) PyThread_tss_set((key), (value))
  27 #    define PYBIND11_TLS_DELETE_VALUE(key) PyThread_tss_set((key), nullptr)
  28 #    define PYBIND11_TLS_FREE(key) PyThread_tss_free(key)
  29 #else
  30     // Usually an int but a long on Cygwin64 with Python 3.x
  31 #    define PYBIND11_TLS_KEY_INIT(var) decltype(PyThread_create_key()) var = 0
  32 #    define PYBIND11_TLS_GET_VALUE(key) PyThread_get_key_value((key))
  33 #    if PY_MAJOR_VERSION < 3
  34 #        define PYBIND11_TLS_DELETE_VALUE(key)                               \
  35              PyThread_delete_key_value(key)
  36 #        define PYBIND11_TLS_REPLACE_VALUE(key, value)                       \
  37              do {                                                            \
  38                  PyThread_delete_key_value((key));                           \
  39                  PyThread_set_key_value((key), (value));                     \
  40              } while (false)
  41 #    else
  42 #        define PYBIND11_TLS_DELETE_VALUE(key)                               \
  43              PyThread_set_key_value((key), nullptr)
  44 #        define PYBIND11_TLS_REPLACE_VALUE(key, value)                       \
  45              PyThread_set_key_value((key), (value))
  46 #    endif
  47 #    define PYBIND11_TLS_FREE(key) (void)key
  48 #endif
  49
  50 // Python loads modules by default with dlopen with the RTLD_LOCAL flag; under libc++ and possibly
  51 // other STLs, this means `typeid(A)` from one module won't equal `typeid(A)` from another module
  52 // even when `A` is the same, non-hidden-visibility type (e.g. from a common include).  Under
  53 // libstdc++, this doesn't happen: equality and the type_index hash are based on the type name,
  54 // which works.  If not under a known-good stl, provide our own name-based hash and equality
  55 // functions that use the type name.
  56 #if defined(__GLIBCXX__)
  57 inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
  58 using type_hash = std::hash<std::type_index>;
  59 using type_equal_to = std::equal_to<std::type_index>;
  60 #else
  61 inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) {
  62     return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0;
  63 }
  64
  65 struct type_hash {
  66     size_t operator()(const std::type_index &t) const {
  67         size_t hash = 5381;
  68         const char *ptr = t.name();
  69         while (auto c = static_cast<unsigned char>(*ptr++))
  70             hash = (hash * 33) ^ c;
  71         return hash;
  72     }
  73 };
  74
  75 struct type_equal_to {
  76     bool operator()(const std::type_index &lhs, const std::type_index &rhs) const {
  77         return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0;
  78     }
  79 };
  80 #endif
  81
  82 template <typename value_type>
  83 using type_map = std::unordered_map<std::type_index, value_type, type_hash, type_equal_to>;
  84
  85 struct overload_hash {
  86     inline size_t operator()(const std::pair<const PyObject *, const char *>& v) const {
  87         size_t value = std::hash<const void *>()(v.first);
  88         value ^= std::hash<const void *>()(v.second)  + 0x9e3779b9 + (value<<6) + (value>>2);
  89         return value;
  90     }
  91 };
  92
  93 /// Internal data structure used to track registered instances and types.
  94 /// Whenever binary incompatible changes are made to this structure,
  95 /// `PYBIND11_INTERNALS_VERSION` must be incremented.
  96 struct internals {
  97     type_map<type_info *> registered_types_cpp; // std::type_index -> pybind11's type information
  98     std::unordered_map<PyTypeObject *, std::vector<type_info *>> registered_types_py; // PyTypeObject* -> base type_info(s)
  99     std::unordered_multimap<const void *, instance*> registered_instances; // void * -> instance*
 100     std::unordered_set<std::pair<const PyObject *, const char *>, overload_hash> inactive_overload_cache;
 101     type_map<std::vector<bool (*)(PyObject *, void *&)>> direct_conversions;
 102     std::unordered_map<const PyObject *, std::vector<PyObject *>> patients;
 103     std::forward_list<void (*) (std::exception_ptr)> registered_exception_translators;
 104     std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across extensions
 105     std::vector<PyObject *> loader_patient_stack; // Used by `loader_life_support`
 106     std::forward_list<std::string> static_strings; // Stores the std::strings backing detail::c_str()
 107     PyTypeObject *static_property_type;
 108     PyTypeObject *default_metaclass;
 109     PyObject *instance_base;
 110 #if defined(WITH_THREAD)
 111     PYBIND11_TLS_KEY_INIT(tstate);
 112     PyInterpreterState *istate = nullptr;
 113     ~internals() {
 114         // This destructor is called *after* Py_Finalize() in finalize_interpreter().
 115         // That *SHOULD BE* fine. The following details what happens whe PyThread_tss_free is called.
 116         // PYBIND11_TLS_FREE is PyThread_tss_free on python 3.7+. On older python, it does nothing.
 117         // PyThread_tss_free calls PyThread_tss_delete and PyMem_RawFree.
 118         // PyThread_tss_delete just calls TlsFree (on Windows) or pthread_key_delete (on *NIX). Neither
 119         // of those have anything to do with CPython internals.
 120         // PyMem_RawFree *requires* that the `tstate` be allocated with the CPython allocator.
 121         PYBIND11_TLS_FREE(tstate);
 122     }
 123 #endif
 124 };
 125
 126 /// Additional type information which does not fit into the PyTypeObject.
 127 /// Changes to this struct also require bumping `PYBIND11_INTERNALS_VERSION`.
 128 struct type_info {
 129     PyTypeObject *type;
 130     const std::type_info *cpptype;
 131     size_t type_size, type_align, holder_size_in_ptrs;
 132     void *(*operator_new)(size_t);
 133     void (*init_instance)(instance *, const void *);
 134     void (*dealloc)(value_and_holder &v_h);
 135     std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions;
 136     std::vector<std::pair<const std::type_info *, void *(*)(void *)>> implicit_casts;
 137     std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;
 138     buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
 139     void *get_buffer_data = nullptr;
 140     void *(*module_local_load)(PyObject *, const type_info *) = nullptr;
 141     /* A simple type never occurs as a (direct or indirect) parent
 142      * of a class that makes use of multiple inheritance */
 143     bool simple_type : 1;
 144     /* True if there is no multiple inheritance in this type's inheritance tree */
 145     bool simple_ancestors : 1;
 146     /* for base vs derived holder_type checks */
 147     bool default_holder : 1;
 148     /* true if this is a type registered with py::module_local */
 149     bool module_local : 1;
 150 };
 151
 152 /// Tracks the `internals` and `type_info` ABI version independent of the main library version
 153 #define PYBIND11_INTERNALS_VERSION 4
 154
 155 /// On MSVC, debug and release builds are not ABI-compatible!
 156 #if defined(_MSC_VER) && defined(_DEBUG)
 157 #   define PYBIND11_BUILD_TYPE "_debug"
 158 #else
 159 #   define PYBIND11_BUILD_TYPE ""
 160 #endif
 161
 162 /// Let's assume that different compilers are ABI-incompatible.
 163 #if defined(_MSC_VER)
 164 #   define PYBIND11_COMPILER_TYPE "_msvc"
 165 #elif defined(__INTEL_COMPILER)
 166 #   define PYBIND11_COMPILER_TYPE "_icc"
 167 #elif defined(__clang__)
 168 #   define PYBIND11_COMPILER_TYPE "_clang"
 169 #elif defined(__PGI)
 170 #   define PYBIND11_COMPILER_TYPE "_pgi"
 171 #elif defined(__MINGW32__)
 172 #   define PYBIND11_COMPILER_TYPE "_mingw"
 173 #elif defined(__CYGWIN__)
 174 #   define PYBIND11_COMPILER_TYPE "_gcc_cygwin"
 175 #elif defined(__GNUC__)
 176 #   define PYBIND11_COMPILER_TYPE "_gcc"
 177 #else
 178 #   define PYBIND11_COMPILER_TYPE "_unknown"
 179 #endif
 180
 181 #if defined(_LIBCPP_VERSION)
 182 #  define PYBIND11_STDLIB "_libcpp"
 183 #elif defined(__GLIBCXX__) || defined(__GLIBCPP__)
 184 #  define PYBIND11_STDLIB "_libstdcpp"
 185 #else
 186 #  define PYBIND11_STDLIB ""
 187 #endif
 188
 189 /// On Linux/OSX, changes in __GXX_ABI_VERSION__ indicate ABI incompatibility.
 190 #if defined(__GXX_ABI_VERSION)
 191 #  define PYBIND11_BUILD_ABI "_cxxabi" PYBIND11_TOSTRING(__GXX_ABI_VERSION)
 192 #else
 193 #  define PYBIND11_BUILD_ABI ""
 194 #endif
 195
 196 #if defined(WITH_THREAD)
 197 #  define PYBIND11_INTERNALS_KIND ""
 198 #else
 199 #  define PYBIND11_INTERNALS_KIND "_without_thread"
 200 #endif
 201
 202 #define PYBIND11_INTERNALS_ID "__pybind11_internals_v" \
 203     PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION) PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE "__"
 204
 205 #define PYBIND11_MODULE_LOCAL_ID "__pybind11_module_local_v" \
 206     PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION) PYBIND11_INTERNALS_KIND PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE "__"
 207
 208 /// Each module locally stores a pointer to the `internals` data. The data
 209 /// itself is shared among modules with the same `PYBIND11_INTERNALS_ID`.
 210 inline internals **&get_internals_pp() {
 211     static internals **internals_pp = nullptr;
 212     return internals_pp;
 213 }
 214
 215 inline void translate_exception(std::exception_ptr p) {
 216     try {
 217         if (p) std::rethrow_exception(p);
 218     } catch (error_already_set &e)           { e.restore();                                    return;
 219     } catch (const builtin_exception &e)     { e.set_error();                                  return;
 220     } catch (const std::bad_alloc &e)        { PyErr_SetString(PyExc_MemoryError,   e.what()); return;
 221     } catch (const std::domain_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return;
 222     } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError,    e.what()); return;
 223     } catch (const std::length_error &e)     { PyErr_SetString(PyExc_ValueError,    e.what()); return;
 224     } catch (const std::out_of_range &e)     { PyErr_SetString(PyExc_IndexError,    e.what()); return;
 225     } catch (const std::range_error &e)      { PyErr_SetString(PyExc_ValueError,    e.what()); return;
 226     } catch (const std::overflow_error &e)   { PyErr_SetString(PyExc_OverflowError, e.what()); return;
 227     } catch (const std::exception &e)        { PyErr_SetString(PyExc_RuntimeError,  e.what()); return;
 228     } catch (...) {
 229         PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!");
 230         return;
 231     }
 232 }
 233
 234 #if !defined(__GLIBCXX__)
 235 inline void translate_local_exception(std::exception_ptr p) {
 236     try {
 237         if (p) std::rethrow_exception(p);
 238     } catch (error_already_set &e)       { e.restore();   return;
 239     } catch (const builtin_exception &e) { e.set_error(); return;
 240     }
 241 }
 242 #endif
 243
 244 /// Return a reference to the current `internals` data
 245 PYBIND11_NOINLINE inline internals &get_internals() {
 246     auto **&internals_pp = get_internals_pp();
 247     if (internals_pp && *internals_pp)
 248         return **internals_pp;
 249
 250     // Ensure that the GIL is held since we will need to make Python calls.
 251     // Cannot use py::gil_scoped_acquire here since that constructor calls get_internals.
 252     struct gil_scoped_acquire_local {
 253         gil_scoped_acquire_local() : state (PyGILState_Ensure()) {}
 254         ~gil_scoped_acquire_local() { PyGILState_Release(state); }
 255         const PyGILState_STATE state;
 256     } gil;
 257
 258     constexpr auto *id = PYBIND11_INTERNALS_ID;
 259     auto builtins = handle(PyEval_GetBuiltins());
 260     if (builtins.contains(id) && isinstance<capsule>(builtins[id])) {
 261         internals_pp = static_cast<internals **>(capsule(builtins[id]));
 262
 263         // We loaded builtins through python's builtins, which means that our `error_already_set`
 264         // and `builtin_exception` may be different local classes than the ones set up in the
 265         // initial exception translator, below, so add another for our local exception classes.
 266         //
 267         // libstdc++ doesn't require this (types there are identified only by name)
 268 #if !defined(__GLIBCXX__)
 269         (*internals_pp)->registered_exception_translators.push_front(&translate_local_exception);
 270 #endif
 271     } else {
 272         if (!internals_pp) internals_pp = new internals*();
 273         auto *&internals_ptr = *internals_pp;
 274         internals_ptr = new internals();
 275 #if defined(WITH_THREAD)
 276         PyEval_InitThreads();
 277         PyThreadState *tstate = PyThreadState_Get();
 278         #if PY_VERSION_HEX >= 0x03070000
 279             internals_ptr->tstate = PyThread_tss_alloc();
 280             if (!internals_ptr->tstate || PyThread_tss_create(internals_ptr->tstate))
 281                 pybind11_fail("get_internals: could not successfully initialize the TSS key!");
 282             PyThread_tss_set(internals_ptr->tstate, tstate);
 283         #else
 284             internals_ptr->tstate = PyThread_create_key();
 285             if (internals_ptr->tstate == -1)
 286                 pybind11_fail("get_internals: could not successfully initialize the TLS key!");
 287             PyThread_set_key_value(internals_ptr->tstate, tstate);
 288         #endif
 289         internals_ptr->istate = tstate->interp;
 290 #endif
 291         builtins[id] = capsule(internals_pp);
 292         internals_ptr->registered_exception_translators.push_front(&translate_exception);
 293         internals_ptr->static_property_type = make_static_property_type();
 294         internals_ptr->default_metaclass = make_default_metaclass();
 295         internals_ptr->instance_base = make_object_base_type(internals_ptr->default_metaclass);
 296     }
 297     return **internals_pp;
 298 }
 299
 300 /// Works like `internals.registered_types_cpp`, but for module-local registered types:
 301 inline type_map<type_info *> &registered_local_types_cpp() {
 302     static type_map<type_info *> locals{};
 303     return locals;
 304 }
 305
 306 /// Constructs a std::string with the given arguments, stores it in `internals`, and returns its
 307 /// `c_str()`.  Such strings objects have a long storage duration -- the internal strings are only
 308 /// cleared when the program exits or after interpreter shutdown (when embedding), and so are
 309 /// suitable for c-style strings needed by Python internals (such as PyTypeObject's tp_name).
 310 template <typename... Args>
 311 const char *c_str(Args &&...args) {
 312     auto &strings = get_internals().static_strings;
 313     strings.emplace_front(std::forward<Args>(args)...);
 314     return strings.front().c_str();
 315 }
 316
 317 NAMESPACE_END(detail)
 318
 319 /// Returns a named pointer that is shared among all extension modules (using the same
 320 /// pybind11 version) running in the current interpreter. Names starting with underscores
 321 /// are reserved for internal usage. Returns `nullptr` if no matching entry was found.
 322 inline PYBIND11_NOINLINE void *get_shared_data(const std::string &name) {
 323     auto &internals = detail::get_internals();
 324     auto it = internals.shared_data.find(name);
 325     return it != internals.shared_data.end() ? it->second : nullptr;
 326 }
 327
 328 /// Set the shared data that can be later recovered by `get_shared_data()`.
 329 inline PYBIND11_NOINLINE void *set_shared_data(const std::string &name, void *data) {
 330     detail::get_internals().shared_data[name] = data;
 331     return data;
 332 }
 333
 334 /// Returns a typed reference to a shared data entry (by using `get_shared_data()`) if
 335 /// such entry exists. Otherwise, a new object of default-constructible type `T` is
 336 /// added to the shared data under the given name and a reference to it is returned.
 337 template<typename T>
 338 T &get_or_create_shared_data(const std::string &name) {
 339     auto &internals = detail::get_internals();
 340     auto it = internals.shared_data.find(name);
 341     T *ptr = (T *) (it != internals.shared_data.end() ? it->second : nullptr);
 342     if (!ptr) {
 343         ptr = new T();
 344         internals.shared_data[name] = ptr;
 345     }
 346     return *ptr;
 347 }
 348
 349 NAMESPACE_END(PYBIND11_NAMESPACE)