Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 1 | //===-- llvm/Support/ManagedStatic.h - Static Global wrapper ----*- C++ -*-===// |
| 2 | // |
||
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
||
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
||
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
||
| 6 | // |
||
| 7 | //===----------------------------------------------------------------------===// |
||
| 8 | // |
||
| 9 | // This file defines the ManagedStatic class and the llvm_shutdown() function. |
||
| 10 | // |
||
| 11 | //===----------------------------------------------------------------------===// |
||
| 12 | |||
| 13 | #ifndef LLVM_SUPPORT_MANAGEDSTATIC_H |
||
| 14 | #define LLVM_SUPPORT_MANAGEDSTATIC_H |
||
| 15 | |||
| 16 | #include <atomic> |
||
| 17 | #include <cstddef> |
||
| 18 | |||
| 19 | namespace llvm { |
||
| 20 | |||
| 21 | /// object_creator - Helper method for ManagedStatic. |
||
| 22 | template <class C> struct object_creator { |
||
| 23 | static void *call() { return new C(); } |
||
| 24 | }; |
||
| 25 | |||
| 26 | /// object_deleter - Helper method for ManagedStatic. |
||
| 27 | /// |
||
| 28 | template <typename T> struct object_deleter { |
||
| 29 | static void call(void *Ptr) { delete (T *)Ptr; } |
||
| 30 | }; |
||
| 31 | template <typename T, size_t N> struct object_deleter<T[N]> { |
||
| 32 | static void call(void *Ptr) { delete[](T *)Ptr; } |
||
| 33 | }; |
||
| 34 | |||
| 35 | // ManagedStatic must be initialized to zero, and it must *not* have a dynamic |
||
| 36 | // initializer because managed statics are often created while running other |
||
| 37 | // dynamic initializers. In standard C++11, the best way to accomplish this is |
||
| 38 | // with a constexpr default constructor. However, different versions of the |
||
| 39 | // Visual C++ compiler have had bugs where, even though the constructor may be |
||
| 40 | // constexpr, a dynamic initializer may be emitted depending on optimization |
||
| 41 | // settings. For the affected versions of MSVC, use the old linker |
||
| 42 | // initialization pattern of not providing a constructor and leaving the fields |
||
| 43 | // uninitialized. See http://llvm.org/PR41367 for details. |
||
| 44 | #if !defined(_MSC_VER) || (_MSC_VER >= 1925) || defined(__clang__) |
||
| 45 | #define LLVM_USE_CONSTEXPR_CTOR |
||
| 46 | #endif |
||
| 47 | |||
| 48 | /// ManagedStaticBase - Common base class for ManagedStatic instances. |
||
| 49 | class ManagedStaticBase { |
||
| 50 | protected: |
||
| 51 | #ifdef LLVM_USE_CONSTEXPR_CTOR |
||
| 52 | mutable std::atomic<void *> Ptr{}; |
||
| 53 | mutable void (*DeleterFn)(void *) = nullptr; |
||
| 54 | mutable const ManagedStaticBase *Next = nullptr; |
||
| 55 | #else |
||
| 56 | // This should only be used as a static variable, which guarantees that this |
||
| 57 | // will be zero initialized. |
||
| 58 | mutable std::atomic<void *> Ptr; |
||
| 59 | mutable void (*DeleterFn)(void *); |
||
| 60 | mutable const ManagedStaticBase *Next; |
||
| 61 | #endif |
||
| 62 | |||
| 63 | void RegisterManagedStatic(void *(*creator)(), void (*deleter)(void*)) const; |
||
| 64 | |||
| 65 | public: |
||
| 66 | #ifdef LLVM_USE_CONSTEXPR_CTOR |
||
| 67 | constexpr ManagedStaticBase() = default; |
||
| 68 | #endif |
||
| 69 | |||
| 70 | /// isConstructed - Return true if this object has not been created yet. |
||
| 71 | bool isConstructed() const { return Ptr != nullptr; } |
||
| 72 | |||
| 73 | void destroy() const; |
||
| 74 | }; |
||
| 75 | |||
| 76 | /// ManagedStatic - This transparently changes the behavior of global statics to |
||
| 77 | /// be lazily constructed on demand (good for reducing startup times of dynamic |
||
| 78 | /// libraries that link in LLVM components) and for making destruction be |
||
| 79 | /// explicit through the llvm_shutdown() function call. |
||
| 80 | /// |
||
| 81 | template <class C, class Creator = object_creator<C>, |
||
| 82 | class Deleter = object_deleter<C>> |
||
| 83 | class ManagedStatic : public ManagedStaticBase { |
||
| 84 | public: |
||
| 85 | // Accessors. |
||
| 86 | C &operator*() { |
||
| 87 | void *Tmp = Ptr.load(std::memory_order_acquire); |
||
| 88 | if (!Tmp) |
||
| 89 | RegisterManagedStatic(Creator::call, Deleter::call); |
||
| 90 | |||
| 91 | return *static_cast<C *>(Ptr.load(std::memory_order_relaxed)); |
||
| 92 | } |
||
| 93 | |||
| 94 | C *operator->() { return &**this; } |
||
| 95 | |||
| 96 | const C &operator*() const { |
||
| 97 | void *Tmp = Ptr.load(std::memory_order_acquire); |
||
| 98 | if (!Tmp) |
||
| 99 | RegisterManagedStatic(Creator::call, Deleter::call); |
||
| 100 | |||
| 101 | return *static_cast<C *>(Ptr.load(std::memory_order_relaxed)); |
||
| 102 | } |
||
| 103 | |||
| 104 | const C *operator->() const { return &**this; } |
||
| 105 | |||
| 106 | // Extract the instance, leaving the ManagedStatic uninitialized. The |
||
| 107 | // user is then responsible for the lifetime of the returned instance. |
||
| 108 | C *claim() { |
||
| 109 | return static_cast<C *>(Ptr.exchange(nullptr)); |
||
| 110 | } |
||
| 111 | }; |
||
| 112 | |||
| 113 | /// llvm_shutdown - Deallocate and destroy all ManagedStatic variables. |
||
| 114 | void llvm_shutdown(); |
||
| 115 | |||
| 116 | /// llvm_shutdown_obj - This is a simple helper class that calls |
||
| 117 | /// llvm_shutdown() when it is destroyed. |
||
| 118 | struct llvm_shutdown_obj { |
||
| 119 | llvm_shutdown_obj() = default; |
||
| 120 | ~llvm_shutdown_obj() { llvm_shutdown(); } |
||
| 121 | }; |
||
| 122 | |||
| 123 | } // end namespace llvm |
||
| 124 | |||
| 125 | #endif // LLVM_SUPPORT_MANAGEDSTATIC_H |