Back out the thread-safe ManagedStatic for now. Too many people have too many proble...
[oota-llvm.git] / include / llvm / Support / ManagedStatic.h
1 //===-- llvm/Support/ManagedStatic.h - Static Global wrapper ----*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the ManagedStatic class and the llvm_shutdown() function.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #ifndef LLVM_SUPPORT_MANAGED_STATIC_H
15 #define LLVM_SUPPORT_MANAGED_STATIC_H
16
17 namespace llvm {
18
19 /// object_deleter - Helper method for ManagedStatic.
20 ///
21 template<class C>
22 void object_deleter(void *Ptr) {
23   delete (C*)Ptr;
24 }
25
26 /// ManagedStaticBase - Common base class for ManagedStatic instances.
27 class ManagedStaticBase {
28 protected:
29   // This should only be used as a static variable, which guarantees that this
30   // will be zero initialized.
31   mutable void *Ptr;
32   mutable void (*DeleterFn)(void*);
33   mutable const ManagedStaticBase *Next;
34
35   void RegisterManagedStatic(void *ObjPtr, void (*deleter)(void*)) const;
36 public:
37   /// isConstructed - Return true if this object has not been created yet.
38   bool isConstructed() const { return Ptr != 0; }
39
40   void destroy() const;
41 };
42
43 /// ManagedStatic - This transparently changes the behavior of global statics to
44 /// be lazily constructed on demand (good for reducing startup times of dynamic
45 /// libraries that link in LLVM components) and for making destruction be
46 /// explicit through the llvm_shutdown() function call.
47 ///
48 template<class C>
49 class ManagedStatic : public ManagedStaticBase {
50 public:
51
52   // Accessors.
53   C &operator*() {
54     if (!Ptr) LazyInit();
55     return *static_cast<C*>(Ptr);
56   }
57   C *operator->() {
58     if (!Ptr) LazyInit();
59     return static_cast<C*>(Ptr);
60   }
61   const C &operator*() const {
62     if (!Ptr) LazyInit();
63     return *static_cast<C*>(Ptr);
64   }
65   const C *operator->() const {
66     if (!Ptr) LazyInit();
67     return static_cast<C*>(Ptr);
68   }
69
70 public:
71   void LazyInit() const {
72     RegisterManagedStatic(new C(), object_deleter<C>);
73   }
74 };
75
76 template<void (*CleanupFn)(void*)>
77 class ManagedCleanup : public ManagedStaticBase {
78 public:
79   void Register() { RegisterManagedStatic(0, CleanupFn); }
80 };
81
82
83 /// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
84 void llvm_shutdown();
85
86
87 /// llvm_shutdown_obj - This is a simple helper class that calls
88 /// llvm_shutdown() when it is destroyed.
89 struct llvm_shutdown_obj {
90   llvm_shutdown_obj() {}
91   ~llvm_shutdown_obj() { llvm_shutdown(); }
92 };
93
94 }
95
96 #endif