LLVM  14.0.0git
ManagedStatic.h
Go to the documentation of this file.
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.
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>>
84 public:
85  // Accessors.
86  C &operator*() {
87  void *Tmp = Ptr.load(std::memory_order_acquire);
88  if (!Tmp)
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)
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.
119  llvm_shutdown_obj() = default;
121 };
122 
123 } // end namespace llvm
124 
125 #endif // LLVM_SUPPORT_MANAGEDSTATIC_H
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
llvm::ManagedStaticBase::Ptr
std::atomic< void * > Ptr
Definition: ManagedStatic.h:52
llvm::ManagedStaticBase::ManagedStaticBase
constexpr ManagedStaticBase()=default
llvm::object_creator
object_creator - Helper method for ManagedStatic.
Definition: ManagedStatic.h:22
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::llvm_shutdown
void llvm_shutdown()
llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
Definition: ManagedStatic.cpp:75
llvm::llvm_shutdown_obj::~llvm_shutdown_obj
~llvm_shutdown_obj()
Definition: ManagedStatic.h:120
llvm::llvm_shutdown_obj
llvm_shutdown_obj - This is a simple helper class that calls llvm_shutdown() when it is destroyed.
Definition: ManagedStatic.h:118
llvm::ManagedStaticBase::Next
const ManagedStaticBase * Next
Definition: ManagedStatic.h:54
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::ManagedStatic
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:83
llvm::ManagedStaticBase
ManagedStaticBase - Common base class for ManagedStatic instances.
Definition: ManagedStatic.h:49
llvm::object_deleter
object_deleter - Helper method for ManagedStatic.
Definition: ManagedStatic.h:28
call
S is passed via registers r2 But gcc stores them to the and then reload them to and r3 before issuing the call(r0 contains the address of the format string)
Definition: README.txt:190
llvm::ManagedStaticBase::DeleterFn
void(* DeleterFn)(void *)
Definition: ManagedStatic.h:53
llvm::ManagedStaticBase::isConstructed
bool isConstructed() const
isConstructed - Return true if this object has not been created yet.
Definition: ManagedStatic.h:71
llvm::ManagedStatic::operator->
const C * operator->() const
Definition: ManagedStatic.h:104
llvm::ManagedStaticBase::destroy
void destroy() const
Definition: ManagedStatic.cpp:55
llvm::object_creator::call
static void * call()
Definition: ManagedStatic.h:23
llvm::ManagedStatic::claim
C * claim()
Definition: ManagedStatic.h:108
llvm::ManagedStatic::operator->
C * operator->()
Definition: ManagedStatic.h:94
llvm::ManagedStaticBase::RegisterManagedStatic
void RegisterManagedStatic(void *(*creator)(), void(*deleter)(void *)) const
Definition: ManagedStatic.cpp:27
llvm::ManagedStatic::operator*
const C & operator*() const
Definition: ManagedStatic.h:96
N
#define N
llvm::object_deleter< T[N]>::call
static void call(void *Ptr)
Definition: ManagedStatic.h:32
llvm::ManagedStatic::operator*
C & operator*()
Definition: ManagedStatic.h:86
llvm::llvm_shutdown_obj::llvm_shutdown_obj
llvm_shutdown_obj()=default
llvm::object_deleter::call
static void call(void *Ptr)
Definition: ManagedStatic.h:29