Switched over to using the new lldb::SharingPtr from Howard Hinnant.
We need to put this in LLDB since we need to vend this in our API
because our public API uses shared pointers to our private objects.
Removed a deprecated file: include/lldb/Host/Types.h
Added the new SharingPtr.cpp/.h files into source/Utility.
Added a shell script build phase that fixes up all headers in the
LLDB.framework.
git-svn-id: https://llvm.org/svn/llvm-project/llvdb/trunk@105895 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/source/Expression/ClangASTSource.cpp b/source/Expression/ClangASTSource.cpp
index 996c205..3bae8b3 100644
--- a/source/Expression/ClangASTSource.cpp
+++ b/source/Expression/ClangASTSource.cpp
@@ -7,8 +7,6 @@
*
*/
-#define NO_RTTI
-
#include "clang/AST/ASTContext.h"
#include "lldb/Expression/ClangASTSource.h"
#include "lldb/Expression/ClangExpression.h"
diff --git a/source/Expression/ClangExpression.cpp b/source/Expression/ClangExpression.cpp
index f7742c6..1892bb6 100644
--- a/source/Expression/ClangExpression.cpp
+++ b/source/Expression/ClangExpression.cpp
@@ -58,7 +58,6 @@
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
-#define NO_RTTI
#include "lldb/Core/StreamString.h"
#include "lldb/Host/Mutex.h"
#include "lldb/Core/dwarf.h"
diff --git a/source/Expression/ClangStmtVisitor.cpp b/source/Expression/ClangStmtVisitor.cpp
index 1d2f53f..b3aeceb 100644
--- a/source/Expression/ClangStmtVisitor.cpp
+++ b/source/Expression/ClangStmtVisitor.cpp
@@ -14,7 +14,6 @@
// Other libraries and framework includes
#include "clang/AST/RecordLayout.h"
-#define NO_RTTI
#include "lldb/Core/dwarf.h"
#include "lldb/Core/Scalar.h"
#include "lldb/Core/StreamString.h"
diff --git a/source/Expression/RecordingMemoryManager.cpp b/source/Expression/RecordingMemoryManager.cpp
index 9f732b6..e1ccdbe 100644
--- a/source/Expression/RecordingMemoryManager.cpp
+++ b/source/Expression/RecordingMemoryManager.cpp
@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
-#define NO_RTTI
// C Includes
// C++ Includes
// Other libraries and framework includes
diff --git a/source/Utility/SharingPtr.cpp b/source/Utility/SharingPtr.cpp
new file mode 100644
index 0000000..431fdc1
--- /dev/null
+++ b/source/Utility/SharingPtr.cpp
@@ -0,0 +1,53 @@
+//===---------------------SharingPtr.cpp ------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SharingPtr.h"
+
+namespace lldb {
+
+namespace imp
+{
+
+template <class T>
+inline T
+increment(T& t)
+{
+ return __sync_add_and_fetch(&t, 1);
+}
+
+template <class T>
+inline T
+decrement(T& t)
+{
+ return __sync_add_and_fetch(&t, -1);
+}
+
+shared_count::~shared_count()
+{
+}
+
+void
+shared_count::add_shared()
+{
+ increment(shared_owners_);
+}
+
+void
+shared_count::release_shared()
+{
+ if (decrement(shared_owners_) == -1)
+ {
+ on_zero_shared();
+ delete this;
+ }
+}
+
+} // imp
+
+} // namespace lldb
diff --git a/source/Utility/SharingPtr.h b/source/Utility/SharingPtr.h
new file mode 100644
index 0000000..f747869
--- /dev/null
+++ b/source/Utility/SharingPtr.h
@@ -0,0 +1,252 @@
+//===---------------------SharingPtr.h --------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_SharingPtr_h_
+#define utility_SharingPtr_h_
+
+#include <algorithm>
+
+namespace lldb {
+
+namespace imp {
+
+class shared_count
+{
+ shared_count(const shared_count&);
+ shared_count& operator=(const shared_count&);
+
+protected:
+ long shared_owners_;
+ virtual ~shared_count();
+private:
+ virtual void on_zero_shared() = 0;
+
+public:
+ explicit shared_count(long refs = 0)
+ : shared_owners_(refs) {}
+
+ void add_shared();
+ void release_shared();
+ long use_count() const {return shared_owners_ + 1;}
+};
+
+template <class T>
+class shared_ptr_pointer
+ : public shared_count
+{
+ T data_;
+public:
+ shared_ptr_pointer(T p)
+ : data_(p) {}
+
+private:
+ virtual void on_zero_shared();
+};
+
+template <class T>
+void
+shared_ptr_pointer<T>::on_zero_shared()
+{
+ delete data_;
+}
+
+} // namespace
+
+template<class T>
+class SharingPtr
+{
+public:
+ typedef T element_type;
+private:
+ element_type* ptr_;
+ imp::shared_count* cntrl_;
+
+public:
+ SharingPtr();
+ template<class Y> explicit SharingPtr(Y* p);
+ template<class Y> SharingPtr(const SharingPtr<Y>& r, element_type *p);
+ SharingPtr(const SharingPtr& r);
+ template<class Y>
+ SharingPtr(const SharingPtr<Y>& r);
+
+ ~SharingPtr();
+
+ SharingPtr& operator=(const SharingPtr& r);
+ template<class Y> SharingPtr& operator=(const SharingPtr<Y>& r);
+
+ void swap(SharingPtr& r);
+ void reset();
+ template<class Y> void reset(Y* p);
+
+ element_type* get() const {return ptr_;}
+ element_type& operator*() const {return *ptr_;}
+ element_type* operator->() const {return ptr_;}
+ long use_count() const {return cntrl_ ? cntrl_->use_count() : 0;}
+ bool unique() const {return use_count() == 1;}
+ bool empty() const {return cntrl_ == 0;}
+ operator void*() const { return get(); }
+
+private:
+
+ template <class U> friend class SharingPtr;
+};
+
+template<class T>
+inline
+SharingPtr<T>::SharingPtr()
+ : ptr_(0),
+ cntrl_(0)
+{
+}
+
+template<class T>
+template<class Y>
+SharingPtr<T>::SharingPtr(Y* p)
+ : ptr_(p)
+{
+ std::auto_ptr<Y> hold(p);
+ typedef imp::shared_ptr_pointer<Y*> _CntrlBlk;
+ cntrl_ = new _CntrlBlk(p);
+ hold.release();
+}
+
+template<class T>
+template<class Y>
+inline
+SharingPtr<T>::SharingPtr(const SharingPtr<Y>& r, element_type *p)
+ : ptr_(p),
+ cntrl_(r.cntrl_)
+{
+ if (cntrl_)
+ cntrl_->add_shared();
+}
+
+template<class T>
+inline
+SharingPtr<T>::SharingPtr(const SharingPtr& r)
+ : ptr_(r.ptr_),
+ cntrl_(r.cntrl_)
+{
+ if (cntrl_)
+ cntrl_->add_shared();
+}
+
+template<class T>
+template<class Y>
+inline
+SharingPtr<T>::SharingPtr(const SharingPtr<Y>& r)
+ : ptr_(r.ptr_),
+ cntrl_(r.cntrl_)
+{
+ if (cntrl_)
+ cntrl_->add_shared();
+}
+
+template<class T>
+SharingPtr<T>::~SharingPtr()
+{
+ if (cntrl_)
+ cntrl_->release_shared();
+}
+
+template<class T>
+inline
+SharingPtr<T>&
+SharingPtr<T>::operator=(const SharingPtr& r)
+{
+ SharingPtr(r).swap(*this);
+ return *this;
+}
+
+template<class T>
+template<class Y>
+inline
+SharingPtr<T>&
+SharingPtr<T>::operator=(const SharingPtr<Y>& r)
+{
+ SharingPtr(r).swap(*this);
+ return *this;
+}
+
+template<class T>
+inline
+void
+SharingPtr<T>::swap(SharingPtr& r)
+{
+ std::swap(ptr_, r.ptr_);
+ std::swap(cntrl_, r.cntrl_);
+}
+
+template<class T>
+inline
+void
+SharingPtr<T>::reset()
+{
+ SharingPtr().swap(*this);
+}
+
+template<class T>
+template<class Y>
+inline
+void
+SharingPtr<T>::reset(Y* p)
+{
+ SharingPtr(p).swap(*this);
+}
+
+template<class T, class U>
+inline
+bool
+operator==(const SharingPtr<T>& __x, const SharingPtr<U>& __y)
+{
+ return __x.get() == __y.get();
+}
+
+template<class T, class U>
+inline
+bool
+operator!=(const SharingPtr<T>& __x, const SharingPtr<U>& __y)
+{
+ return !(__x == __y);
+}
+
+template<class T, class U>
+inline
+bool
+operator<(const SharingPtr<T>& __x, const SharingPtr<U>& __y)
+{
+ return __x.get() < __y.get();
+}
+
+template<class T>
+inline
+void
+swap(SharingPtr<T>& __x, SharingPtr<T>& __y)
+{
+ __x.swap(__y);
+}
+
+template<class T, class U>
+inline
+SharingPtr<T>
+static_pointer_cast(const SharingPtr<U>& r)
+{
+ return SharingPtr<T>(r, static_cast<T*>(r.get()));
+}
+
+template<class T, class U>
+SharingPtr<T>
+const_pointer_cast(const SharingPtr<U>& r)
+{
+ return SharingPtr<T>(r, const_cast<T*>(r.get()));
+}
+
+} // namespace lldb
+
+#endif // utility_SharingPtr_h_