1//== llvm/ADT/IntrusiveRefCntPtr.h - Smart Refcounting Pointer ---*- 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 IntrusiveRefCntPtr, a template class that
11// implements a "smart" pointer for objects that maintain their own
12// internal reference count, and RefCountedBase/RefCountedBaseVPTR, two
13// generic base classes for objects that wish to have their lifetimes
14// managed using reference counting.
15//
16// IntrusiveRefCntPtr is similar to Boost's intrusive_ptr with added
17// LLVM-style casting.
18//
19//===----------------------------------------------------------------------===//
20
21#ifndef LLVM_ADT_INTRUSIVEREFCNTPTR_H
22#define LLVM_ADT_INTRUSIVEREFCNTPTR_H
23
24#include <atomic>
25#include <cassert>
26#include <cstddef>
27
28namespace llvm {
29
30  template <class T>
31  class IntrusiveRefCntPtr;
32
33//===----------------------------------------------------------------------===//
34/// RefCountedBase - A generic base class for objects that wish to
35///  have their lifetimes managed using reference counts. Classes
36///  subclass RefCountedBase to obtain such functionality, and are
37///  typically handled with IntrusiveRefCntPtr "smart pointers" (see below)
38///  which automatically handle the management of reference counts.
39///  Objects that subclass RefCountedBase should not be allocated on
40///  the stack, as invoking "delete" (which is called when the
41///  reference count hits 0) on such objects is an error.
42//===----------------------------------------------------------------------===//
43  template <class Derived>
44  class RefCountedBase {
45    mutable unsigned ref_cnt;
46
47  public:
48    RefCountedBase() : ref_cnt(0) {}
49    RefCountedBase(const RefCountedBase &) : ref_cnt(0) {}
50
51    void Retain() const { ++ref_cnt; }
52    void Release() const {
53      assert (ref_cnt > 0 && "Reference count is already zero.");
54      if (--ref_cnt == 0) delete static_cast<const Derived*>(this);
55    }
56  };
57
58//===----------------------------------------------------------------------===//
59/// RefCountedBaseVPTR - A class that has the same function as
60///  RefCountedBase, but with a virtual destructor. Should be used
61///  instead of RefCountedBase for classes that already have virtual
62///  methods to enforce dynamic allocation via 'new'. Classes that
63///  inherit from RefCountedBaseVPTR can't be allocated on stack -
64///  attempting to do this will produce a compile error.
65//===----------------------------------------------------------------------===//
66  class RefCountedBaseVPTR {
67    mutable unsigned ref_cnt;
68    virtual void anchor();
69
70  protected:
71    RefCountedBaseVPTR() : ref_cnt(0) {}
72    RefCountedBaseVPTR(const RefCountedBaseVPTR &) : ref_cnt(0) {}
73
74    virtual ~RefCountedBaseVPTR() {}
75
76    void Retain() const { ++ref_cnt; }
77    void Release() const {
78      assert (ref_cnt > 0 && "Reference count is already zero.");
79      if (--ref_cnt == 0) delete this;
80    }
81
82    template <typename T>
83    friend struct IntrusiveRefCntPtrInfo;
84  };
85
86
87  template <typename T> struct IntrusiveRefCntPtrInfo {
88    static void retain(T *obj) { obj->Retain(); }
89    static void release(T *obj) { obj->Release(); }
90  };
91
92/// \brief A thread-safe version of \c llvm::RefCountedBase.
93///
94/// A generic base class for objects that wish to have their lifetimes managed
95/// using reference counts. Classes subclass \c ThreadSafeRefCountedBase to
96/// obtain such functionality, and are typically handled with
97/// \c IntrusiveRefCntPtr "smart pointers" which automatically handle the
98/// management of reference counts.
99template <class Derived>
100class ThreadSafeRefCountedBase {
101  mutable std::atomic<int> RefCount;
102
103protected:
104  ThreadSafeRefCountedBase() : RefCount(0) {}
105
106public:
107  void Retain() const { ++RefCount; }
108
109  void Release() const {
110    int NewRefCount = --RefCount;
111    assert(NewRefCount >= 0 && "Reference count was already zero.");
112    if (NewRefCount == 0)
113      delete static_cast<const Derived*>(this);
114  }
115};
116
117//===----------------------------------------------------------------------===//
118/// IntrusiveRefCntPtr - A template class that implements a "smart pointer"
119///  that assumes the wrapped object has a reference count associated
120///  with it that can be managed via calls to
121///  IntrusivePtrAddRef/IntrusivePtrRelease.  The smart pointers
122///  manage reference counts via the RAII idiom: upon creation of
123///  smart pointer the reference count of the wrapped object is
124///  incremented and upon destruction of the smart pointer the
125///  reference count is decremented.  This class also safely handles
126///  wrapping NULL pointers.
127///
128/// Reference counting is implemented via calls to
129///  Obj->Retain()/Obj->Release(). Release() is required to destroy
130///  the object when the reference count reaches zero. Inheriting from
131///  RefCountedBase/RefCountedBaseVPTR takes care of this
132///  automatically.
133//===----------------------------------------------------------------------===//
134  template <typename T>
135  class IntrusiveRefCntPtr {
136    T* Obj;
137
138  public:
139    typedef T element_type;
140
141    explicit IntrusiveRefCntPtr() : Obj(nullptr) {}
142
143    IntrusiveRefCntPtr(T* obj) : Obj(obj) {
144      retain();
145    }
146
147    IntrusiveRefCntPtr(const IntrusiveRefCntPtr& S) : Obj(S.Obj) {
148      retain();
149    }
150
151    IntrusiveRefCntPtr(IntrusiveRefCntPtr&& S) : Obj(S.Obj) {
152      S.Obj = nullptr;
153    }
154
155    template <class X>
156    IntrusiveRefCntPtr(IntrusiveRefCntPtr<X>&& S) : Obj(S.get()) {
157      S.Obj = 0;
158    }
159
160    template <class X>
161    IntrusiveRefCntPtr(const IntrusiveRefCntPtr<X>& S)
162      : Obj(S.get()) {
163      retain();
164    }
165
166    IntrusiveRefCntPtr& operator=(IntrusiveRefCntPtr S) {
167      swap(S);
168      return *this;
169    }
170
171    ~IntrusiveRefCntPtr() { release(); }
172
173    T& operator*() const { return *Obj; }
174
175    T* operator->() const { return Obj; }
176
177    T* get() const { return Obj; }
178
179    explicit operator bool() const { return Obj; }
180
181    void swap(IntrusiveRefCntPtr& other) {
182      T* tmp = other.Obj;
183      other.Obj = Obj;
184      Obj = tmp;
185    }
186
187    void reset() {
188      release();
189      Obj = nullptr;
190    }
191
192    void resetWithoutRelease() {
193      Obj = 0;
194    }
195
196  private:
197    void retain() { if (Obj) IntrusiveRefCntPtrInfo<T>::retain(Obj); }
198    void release() { if (Obj) IntrusiveRefCntPtrInfo<T>::release(Obj); }
199
200    template <typename X>
201    friend class IntrusiveRefCntPtr;
202  };
203
204  template<class T, class U>
205  inline bool operator==(const IntrusiveRefCntPtr<T>& A,
206                         const IntrusiveRefCntPtr<U>& B)
207  {
208    return A.get() == B.get();
209  }
210
211  template<class T, class U>
212  inline bool operator!=(const IntrusiveRefCntPtr<T>& A,
213                         const IntrusiveRefCntPtr<U>& B)
214  {
215    return A.get() != B.get();
216  }
217
218  template<class T, class U>
219  inline bool operator==(const IntrusiveRefCntPtr<T>& A,
220                         U* B)
221  {
222    return A.get() == B;
223  }
224
225  template<class T, class U>
226  inline bool operator!=(const IntrusiveRefCntPtr<T>& A,
227                         U* B)
228  {
229    return A.get() != B;
230  }
231
232  template<class T, class U>
233  inline bool operator==(T* A,
234                         const IntrusiveRefCntPtr<U>& B)
235  {
236    return A == B.get();
237  }
238
239  template<class T, class U>
240  inline bool operator!=(T* A,
241                         const IntrusiveRefCntPtr<U>& B)
242  {
243    return A != B.get();
244  }
245
246  template <class T>
247  bool operator==(std::nullptr_t A, const IntrusiveRefCntPtr<T> &B) {
248    return !B;
249  }
250
251  template <class T>
252  bool operator==(const IntrusiveRefCntPtr<T> &A, std::nullptr_t B) {
253    return B == A;
254  }
255
256  template <class T>
257  bool operator!=(std::nullptr_t A, const IntrusiveRefCntPtr<T> &B) {
258    return !(A == B);
259  }
260
261  template <class T>
262  bool operator!=(const IntrusiveRefCntPtr<T> &A, std::nullptr_t B) {
263    return !(A == B);
264  }
265
266//===----------------------------------------------------------------------===//
267// LLVM-style downcasting support for IntrusiveRefCntPtr objects
268//===----------------------------------------------------------------------===//
269
270  template <typename From> struct simplify_type;
271
272  template<class T> struct simplify_type<IntrusiveRefCntPtr<T> > {
273    typedef T* SimpleType;
274    static SimpleType getSimplifiedValue(IntrusiveRefCntPtr<T>& Val) {
275      return Val.get();
276    }
277  };
278
279  template<class T> struct simplify_type<const IntrusiveRefCntPtr<T> > {
280    typedef /*const*/ T* SimpleType;
281    static SimpleType getSimplifiedValue(const IntrusiveRefCntPtr<T>& Val) {
282      return Val.get();
283    }
284  };
285
286} // end namespace llvm
287
288#endif // LLVM_ADT_INTRUSIVEREFCNTPTR_H
289