Yi Kong | 8328301 | 2023-12-13 12:57:00 +0900 | [diff] [blame^] | 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 |