ManagedStatic.h revision 363496
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 19namespace llvm { 20 21/// object_creator - Helper method for ManagedStatic. 22template <class C> struct object_creator { 23 static void *call() { return new C(); } 24}; 25 26/// object_deleter - Helper method for ManagedStatic. 27/// 28template <typename T> struct object_deleter { 29 static void call(void *Ptr) { delete (T *)Ptr; } 30}; 31template <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. 49class ManagedStaticBase { 50protected: 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 65public: 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/// 81template <class C, class Creator = object_creator<C>, 82 class Deleter = object_deleter<C>> 83class ManagedStatic : public ManagedStaticBase { 84public: 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. 114void llvm_shutdown(); 115 116/// llvm_shutdown_obj - This is a simple helper class that calls 117/// llvm_shutdown() when it is destroyed. 118struct 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 126