Home | History | Annotate | Line # | Download | only in Support 
      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
    126