LLVM 20.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
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.
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>>
84public:
85 // Accessors.
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.
119 llvm_shutdown_obj() = default;
121};
122
123} // end namespace llvm
124
125#endif // LLVM_SUPPORT_MANAGEDSTATIC_H
ManagedStaticBase - Common base class for ManagedStatic instances.
Definition: ManagedStatic.h:49
void RegisterManagedStatic(void *(*creator)(), void(*deleter)(void *)) const
constexpr ManagedStaticBase()=default
void(* DeleterFn)(void *)
Definition: ManagedStatic.h:53
const ManagedStaticBase * Next
Definition: ManagedStatic.h:54
std::atomic< void * > Ptr
Definition: ManagedStatic.h:52
bool isConstructed() const
isConstructed - Return true if this object has not been created yet.
Definition: ManagedStatic.h:71
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:83
const C * operator->() const
const C & operator*() const
Definition: ManagedStatic.h:96
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void llvm_shutdown()
llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
#define N
llvm_shutdown_obj - This is a simple helper class that calls llvm_shutdown() when it is destroyed.
object_creator - Helper method for ManagedStatic.
Definition: ManagedStatic.h:22
static void * call()
Definition: ManagedStatic.h:23
static void call(void *Ptr)
Definition: ManagedStatic.h:32
object_deleter - Helper method for ManagedStatic.
Definition: ManagedStatic.h:28
static void call(void *Ptr)
Definition: ManagedStatic.h:29