Import LLDB as of upstream SVN r225923 (git 2b588ecd)

This corresponds with the branchpoint for the 3.6 release.
A number of files not required for the FreeBSD build have been removed.

Sponsored by:	DARPA, AFRL

1 files changed, 170 insertions, 3 deletions

diff --git a/source/API/SBType.cpp b/source/API/SBType.cpp
index 064fb32..8a0f5d8 100644
--- a/source/API/SBType.cpp
+++ b/source/API/SBType.cpp
@@ -156,6 +156,14 @@ SBType::IsPointerType()
 }
 
 bool
+SBType::IsArrayType()
+{
+    if (!IsValid())
+        return false;
+    return m_opaque_sp->GetClangASTType(true).IsArrayType(nullptr, nullptr, nullptr);
+}
+
+bool
 SBType::IsReferenceType()
 {
     if (!IsValid())
@@ -204,6 +212,14 @@ SBType::GetDereferencedType()
     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())));
 }
 
+SBType
+SBType::GetArrayElementType()
+{
+    if (!IsValid())
+        return SBType();
+    return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetClangASTType(true).GetArrayElementType())));
+}
+
 bool 
 SBType::IsFunctionType ()
 {
@@ -220,7 +236,13 @@ SBType::IsPolymorphicClass ()
     return m_opaque_sp->GetClangASTType(true).IsPolymorphicClass();
 }
 
-
+bool
+SBType::IsTypedefType ()
+{
+    if (!IsValid())
+        return false;
+    return m_opaque_sp->GetClangASTType(true).IsTypedefType();
+}
 
 lldb::SBType
 SBType::GetFunctionReturnType ()
@@ -252,6 +274,25 @@ SBType::GetFunctionArgumentTypes ()
     return sb_type_list;
 }
 
+uint32_t
+SBType::GetNumberOfMemberFunctions ()
+{
+    if (IsValid())
+    {
+        return m_opaque_sp->GetClangASTType(true).GetNumMemberFunctions();
+    }
+    return 0;
+}
+
+lldb::SBTypeMemberFunction
+SBType::GetMemberFunctionAtIndex (uint32_t idx)
+{
+    SBTypeMemberFunction sb_func_type;
+    if (IsValid())
+        sb_func_type.reset(new TypeMemberFunctionImpl(m_opaque_sp->GetClangASTType(true).GetMemberFunctionAtIndex(idx)));
+    return sb_func_type;
+}
+
 lldb::SBType
 SBType::GetUnqualifiedType()
 {
@@ -305,7 +346,7 @@ uint32_t
 SBType::GetNumberOfFields ()
 {
     if (IsValid())
-        return m_opaque_sp->GetClangASTType(false).GetNumFields();
+        return m_opaque_sp->GetClangASTType(true).GetNumFields();
     return 0;
 }
 
@@ -430,6 +471,14 @@ SBType::IsTypeComplete()
     return m_opaque_sp->GetClangASTType(false).IsCompleteType();
 }
 
+uint32_t
+SBType::GetTypeFlags ()
+{
+    if (!IsValid())
+        return 0;
+    return m_opaque_sp->GetClangASTType(true).GetTypeInfo();
+}
+
 const char*
 SBType::GetName()
 {
@@ -450,7 +499,7 @@ lldb::TypeClass
 SBType::GetTypeClass ()
 {
     if (IsValid())
-        return m_opaque_sp->GetClangASTType(false).GetTypeClass();
+        return m_opaque_sp->GetClangASTType(true).GetTypeClass();
     return lldb::eTypeClassInvalid;
 }
 
@@ -684,3 +733,121 @@ SBTypeMember::ref () const
 {
     return *m_opaque_ap.get();
 }
+
+SBTypeMemberFunction::SBTypeMemberFunction() :
+m_opaque_sp()
+{
+}
+
+SBTypeMemberFunction::~SBTypeMemberFunction()
+{
+}
+
+SBTypeMemberFunction::SBTypeMemberFunction (const SBTypeMemberFunction& rhs) :
+    m_opaque_sp(rhs.m_opaque_sp)
+{
+}
+
+lldb::SBTypeMemberFunction&
+SBTypeMemberFunction::operator = (const lldb::SBTypeMemberFunction& rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
+bool
+SBTypeMemberFunction::IsValid() const
+{
+    return m_opaque_sp.get();
+}
+
+const char *
+SBTypeMemberFunction::GetName ()
+{
+    if (m_opaque_sp)
+        return m_opaque_sp->GetName().GetCString();
+    return NULL;
+}
+
+SBType
+SBTypeMemberFunction::GetType ()
+{
+    SBType sb_type;
+    if (m_opaque_sp)
+    {
+        sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
+    }
+    return sb_type;
+}
+
+lldb::SBType
+SBTypeMemberFunction::GetReturnType ()
+{
+    SBType sb_type;
+    if (m_opaque_sp)
+    {
+        sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
+    }
+    return sb_type;
+}
+
+uint32_t
+SBTypeMemberFunction::GetNumberOfArguments ()
+{
+    if (m_opaque_sp)
+        return m_opaque_sp->GetNumArguments();
+    return 0;
+}
+
+lldb::SBType
+SBTypeMemberFunction::GetArgumentTypeAtIndex (uint32_t i)
+{
+    SBType sb_type;
+    if (m_opaque_sp)
+    {
+        sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
+    }
+    return sb_type;
+}
+
+lldb::MemberFunctionKind
+SBTypeMemberFunction::GetKind ()
+{
+    if (m_opaque_sp)
+        return m_opaque_sp->GetKind();
+    return lldb::eMemberFunctionKindUnknown;
+    
+}
+
+bool
+SBTypeMemberFunction::GetDescription (lldb::SBStream &description,
+                                      lldb::DescriptionLevel description_level)
+{
+    Stream &strm = description.ref();
+    
+    if (m_opaque_sp)
+        return m_opaque_sp->GetDescription(strm);
+    
+    return false;
+}
+
+void
+SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl)
+{
+    m_opaque_sp.reset(type_member_impl);
+}
+
+TypeMemberFunctionImpl &
+SBTypeMemberFunction::ref ()
+{
+    if (!m_opaque_sp)
+        m_opaque_sp.reset (new TypeMemberFunctionImpl());
+    return *m_opaque_sp.get();
+}
+
+const TypeMemberFunctionImpl &
+SBTypeMemberFunction::ref () const
+{
+    return *m_opaque_sp.get();
+}