Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  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.