RegisterPresssureTracker: Track live physical register by unit.

[oota-llvm.git] / include / llvm / ADT / OwningPtr.h

diff --git a/include/llvm/ADT/OwningPtr.h b/include/llvm/ADT/OwningPtr.h
index 7007d25a41bf3bfa8133315195ff1b2ace18ae34..ea229916f90d5c1ff8416888be9ea8289af94edd 100644 (file)
--- a/include/llvm/ADT/OwningPtr.h
+++ b/include/llvm/ADT/OwningPtr.h
@@ -14,7 +14,9 @@
 #ifndef LLVM_ADT_OWNING_PTR_H
 #define LLVM_ADT_OWNING_PTR_H
 
+#include "llvm/Support/Compiler.h"
 #include <cassert>
+#include <cstddef>
 
 namespace llvm {
 
@@ -22,14 +24,23 @@ namespace llvm {
 /// guarantees deletion of the object pointed to, either on destruction of the
 /// OwningPtr or via an explicit reset().  Once created, ownership of the
 /// pointee object can be taken away from OwningPtr by using the take method.
-template<class T> 
+template<class T>
 class OwningPtr {
-  OwningPtr(OwningPtr const &);             // DO NOT IMPLEMENT
-  OwningPtr &operator=(OwningPtr const &); // DO NOT IMPLEMENT
+  OwningPtr(OwningPtr const &) LLVM_DELETED_FUNCTION;
+  OwningPtr &operator=(OwningPtr const &) LLVM_DELETED_FUNCTION;
   T *Ptr;
 public:
   explicit OwningPtr(T *P = 0) : Ptr(P) {}
 
+#if LLVM_HAS_RVALUE_REFERENCES
+  OwningPtr(OwningPtr &&Other) : Ptr(Other.take()) {}
+
+  OwningPtr &operator=(OwningPtr &&Other) {
+    reset(Other.take());
+    return *this;
+  }
+#endif
+
   ~OwningPtr() {
     delete Ptr;
   }
@@ -37,7 +48,7 @@ public:
   /// reset - Change the current pointee to the specified pointer.  Note that
   /// calling this with any pointer (including a null pointer) deletes the
   /// current pointer.
-  void reset(T *P = 0) { 
+  void reset(T *P = 0) {
     if (P == Ptr) return;
     T *Tmp = Ptr;
     Ptr = P;
@@ -46,12 +57,12 @@ public:
 
   /// take - Reset the owning pointer to null and return its pointer.  This does
   /// not delete the pointer before returning it.
-  T *take() { 
+  T *take() {
     T *Tmp = Ptr;
     Ptr = 0;
     return Tmp;
   }
-  
+
   T &operator*() const {
     assert(Ptr && "Cannot dereference null pointer");
     return *Ptr;
@@ -76,14 +87,23 @@ inline void swap(OwningPtr<T> &a, OwningPtr<T> &b) {
 
 /// OwningArrayPtr smart pointer - OwningArrayPtr provides the same
 ///  functionality as OwningPtr, except that it works for array types.
-template<class T> 
+template<class T>
 class OwningArrayPtr {
-  OwningArrayPtr(OwningArrayPtr const &);            // DO NOT IMPLEMENT
-  OwningArrayPtr &operator=(OwningArrayPtr const &); // DO NOT IMPLEMENT
+  OwningArrayPtr(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
+  OwningArrayPtr &operator=(OwningArrayPtr const &) LLVM_DELETED_FUNCTION;
   T *Ptr;
 public:
   explicit OwningArrayPtr(T *P = 0) : Ptr(P) {}
 
+#if LLVM_HAS_RVALUE_REFERENCES
+  OwningArrayPtr(OwningArrayPtr &&Other) : Ptr(Other.take()) {}
+
+  OwningArrayPtr &operator=(OwningArrayPtr &&Other) {
+    reset(Other.take());
+    return *this;
+  }
+#endif
+
   ~OwningArrayPtr() {
     delete [] Ptr;
   }
@@ -91,26 +111,26 @@ public:
   /// reset - Change the current pointee to the specified pointer.  Note that
   /// calling this with any pointer (including a null pointer) deletes the
   /// current pointer.
-  void reset(T *P = 0) { 
+  void reset(T *P = 0) {
     if (P == Ptr) return;
     T *Tmp = Ptr;
     Ptr = P;
-    delete Tmp;
+    delete [] Tmp;
   }
 
   /// take - Reset the owning pointer to null and return its pointer.  This does
   /// not delete the pointer before returning it.
-  T *take() { 
+  T *take() {
     T *Tmp = Ptr;
     Ptr = 0;
     return Tmp;
   }
-  
+
   T &operator[](std::ptrdiff_t i) const {
     assert(Ptr && "Cannot dereference null pointer");
     return Ptr[i];
   }
- 
+
   T *get() const { return Ptr; }
   operator bool() const { return Ptr != 0; }
   bool operator!() const { return Ptr == 0; }
@@ -127,7 +147,6 @@ inline void swap(OwningArrayPtr<T> &a, OwningArrayPtr<T> &b) {
   a.swap(b);
 }
 
-
 } // end namespace llvm
 
 #endif