diff --git a/lldb/include/lldb/API/SBFrame.h b/lldb/include/lldb/API/SBFrame.h index 7729290fda9f..47c59a908cef 100644 --- a/lldb/include/lldb/API/SBFrame.h +++ b/lldb/include/lldb/API/SBFrame.h @@ -200,8 +200,8 @@ private: lldb_private::StackFrame * get() const; - const lldb::StackFrameSP & - get_sp() const; + lldb::StackFrameSP & + get_sp(); #endif diff --git a/lldb/include/lldb/API/SBType.h b/lldb/include/lldb/API/SBType.h index 5ef83130016a..5989ea769d47 100644 --- a/lldb/include/lldb/API/SBType.h +++ b/lldb/include/lldb/API/SBType.h @@ -16,23 +16,125 @@ namespace lldb { class SBTypeList; +class SBTypeMember +{ +public: + SBTypeMember (); + + SBTypeMember (const lldb::SBTypeMember& rhs); + + ~SBTypeMember(); + +#ifndef SWIG + lldb::SBTypeMember& + operator = (const lldb::SBTypeMember& rhs); +#endif + + bool + IsValid() const; + + const char * + GetName (); + + lldb::SBType + GetType (); + + uint64_t + GetOffsetByteSize(); + +protected: + friend class SBType; + +#ifndef SWIG + void + reset (lldb_private::TypeMemberImpl *); + + lldb_private::TypeMemberImpl & + ref (); + + const lldb_private::TypeMemberImpl & + ref () const; +#endif + + std::auto_ptr m_opaque_ap; +}; + class SBType { public: - SBType (const SBType &rhs); + SBType(); + + SBType (const lldb::SBType &rhs); ~SBType (); + bool + IsValid() const; + + size_t + GetByteSize(); + + bool + IsPointerType(); + + bool + IsReferenceType(); + + lldb::SBType + GetPointerType(); + + lldb::SBType + GetPointeeType(); + + lldb::SBType + GetReferenceType(); + + lldb::SBType + GetDereferencedType(); + + lldb::SBType + GetBasicType(lldb::BasicType type); + + uint32_t + GetNumberOfFields (); + + uint32_t + GetNumberOfDirectBaseClasses (); + + uint32_t + GetNumberOfVirtualBaseClasses (); + + lldb::SBTypeMember + GetFieldAtIndex (uint32_t idx); + + lldb::SBTypeMember + GetDirectBaseClassAtIndex (uint32_t idx); + + lldb::SBTypeMember + GetVirtualBaseClassAtIndex (uint32_t idx); + + const char* + GetName(); + + lldb::TypeClass + GetTypeClass (); + + // DEPRECATED: but needed for Xcode right now + static bool + IsPointerType (void * clang_type); + +protected: + #ifndef SWIG - const lldb::SBType & + lldb::SBType & operator = (const lldb::SBType &rhs); bool - operator == (const lldb::SBType &rhs) const; + operator == (lldb::SBType &rhs); bool - operator != (const lldb::SBType &rhs) const; + operator != (lldb::SBType &rhs); lldb_private::TypeImpl & ref (); @@ -40,54 +142,22 @@ public: const lldb_private::TypeImpl & ref () const; + void + reset(const lldb::TypeImplSP &type_impl_sp); #endif - bool - IsValid() const; - - size_t - GetByteSize() const; - bool - IsPointerType() const; - - bool - IsReferenceType() const; - - SBType - GetPointerType() const; - - SBType - GetPointeeType() const; - - SBType - GetReferenceType() const; - - SBType - GetDereferencedType() const; - - SBType - GetBasicType(lldb::BasicType type) const; - - const char* - GetName(); - - // DEPRECATED: but needed for Xcode right now - static bool - IsPointerType (void * clang_type); - -protected: lldb::TypeImplSP m_opaque_sp; friend class SBModule; friend class SBTarget; friend class SBValue; + friend class SBTypeMember; friend class SBTypeList; SBType (const lldb_private::ClangASTType &); SBType (const lldb::TypeSP &); SBType (const lldb::TypeImplSP &); - SBType(); }; @@ -96,28 +166,30 @@ class SBTypeList public: SBTypeList(); - SBTypeList(const SBTypeList& rhs); - - SBTypeList& - operator = (const SBTypeList& rhs); - - bool - IsValid() const; - - void - Append (const SBType& type); - - SBType - GetTypeAtIndex(int index) const; - - int - GetSize() const; + SBTypeList(const lldb::SBTypeList& rhs); ~SBTypeList(); + + lldb::SBTypeList& + operator = (const lldb::SBTypeList& rhs); + + bool + IsValid(); + + void + Append (lldb::SBType type); + + lldb::SBType + GetTypeAtIndex (uint32_t index); + + uint32_t + GetSize(); + private: std::auto_ptr m_opaque_ap; }; + } // namespace lldb diff --git a/lldb/include/lldb/API/SBValue.h b/lldb/include/lldb/API/SBValue.h index 44ec2cdb8a3e..48fa0f3b4788 100644 --- a/lldb/include/lldb/API/SBValue.h +++ b/lldb/include/lldb/API/SBValue.h @@ -22,17 +22,17 @@ class SBValue public: SBValue (); - SBValue (const SBValue &rhs); + SBValue (const lldb::SBValue &rhs); #ifndef SWIG - const SBValue & - operator =(const SBValue &rhs); + lldb::SBValue & + operator =(const lldb::SBValue &rhs); #endif ~SBValue (); bool - IsValid() const; + IsValid(); SBError GetError(); @@ -49,29 +49,23 @@ public: size_t GetByteSize (); - bool - IsInScope (const lldb::SBFrame &frame); // DEPRECATED - SBValues know their own frames. - bool IsInScope (); lldb::Format - GetFormat () const; + GetFormat (); void SetFormat (lldb::Format format); - const char * - GetValue (const lldb::SBFrame &frame); // DEPRECATED - SBValues know their own frames. - const char * GetValue (); int64_t - GetValueAsSigned(SBError& error, int64_t fail_value=0); + GetValueAsSigned (lldb::SBError& error, int64_t fail_value=0); uint64_t - GetValueAsUnsigned(SBError& error, uint64_t fail_value=0); + GetValueAsUnsigned (lldb::SBError& error, uint64_t fail_value=0); int64_t GetValueAsSigned(int64_t fail_value=0); @@ -82,33 +76,18 @@ public: ValueType GetValueType (); - bool - GetValueDidChange (const lldb::SBFrame &frame); // DEPRECATED - SBValues know their own frames. - bool GetValueDidChange (); - const char * - GetSummary (const lldb::SBFrame &frame); // DEPRECATED - SBValues know their own frames. - const char * GetSummary (); - const char * - GetObjectDescription (const lldb::SBFrame &frame); // DEPRECATED - SBValues know their own frames. - const char * GetObjectDescription (); - const char * - GetLocation (const lldb::SBFrame &frame); // DEPRECATED - SBValues know their own frames. - const char * GetLocation (); - bool - SetValueFromCString (const lldb::SBFrame &frame, const char *value_str); // DEPRECATED - SBValues know their own frames. - bool SetValueFromCString (const char *value_str); @@ -116,23 +95,25 @@ public: GetChildAtIndex (uint32_t idx); lldb::SBValue - CreateChildAtOffset (const char *name, uint32_t offset, const SBType& type); + CreateChildAtOffset (const char *name, uint32_t offset, lldb::SBType type); lldb::SBValue - Cast(const SBType& type); + Cast (lldb::SBType type); lldb::SBValue CreateValueFromExpression (const char *name, const char* expression); lldb::SBValue - CreateValueFromAddress(const char* name, lldb::addr_t address, const SBType& type); + CreateValueFromAddress (const char* name, + lldb::addr_t address, + lldb::SBType type); // this has no address! GetAddress() and GetLoadAddress() as well as AddressOf() // on the return of this call all return invalid lldb::SBValue CreateValueFromData (const char* name, - const SBData& data, - const SBType& type); + lldb::SBData data, + lldb::SBType type); //------------------------------------------------------------------ /// Get a child value by index from a value. @@ -279,7 +260,7 @@ public: bool TypeIsPointerType (); - SBType + lldb::SBType GetType(); bool @@ -289,7 +270,8 @@ public: GetExpressionPath (lldb::SBStream &description); bool - GetExpressionPath (lldb::SBStream &description, bool qualify_cxx_base_classes); + GetExpressionPath (lldb::SBStream &description, + bool qualify_cxx_base_classes); SBValue (const lldb::ValueObjectSP &value_sp); @@ -298,8 +280,8 @@ public: // currently rely on being able to extract the SharedPointer out of an SBValue. if the implementation // is deferred to the .cpp file instead of being inlined here, the platform will fail to link // correctly. however, this is temporary till a better general solution is found. FIXME - const lldb::ValueObjectSP& - get_sp() const + lldb::ValueObjectSP& + get_sp() { return m_opaque_sp; } diff --git a/lldb/include/lldb/Symbol/ClangASTContext.h b/lldb/include/lldb/Symbol/ClangASTContext.h index ffd5e1b16f43..8fbd99cf1b60 100644 --- a/lldb/include/lldb/Symbol/ClangASTContext.h +++ b/lldb/include/lldb/Symbol/ClangASTContext.h @@ -413,6 +413,37 @@ public: lldb::clang_type_t clang_type, bool omit_empty_base_classes); + static uint32_t + GetNumDirectBaseClasses (clang::ASTContext *ast, + lldb::clang_type_t clang_type); + + static uint32_t + GetNumVirtualBaseClasses (clang::ASTContext *ast, + lldb::clang_type_t clang_type); + + static uint32_t + GetNumFields (clang::ASTContext *ast, + lldb::clang_type_t clang_type); + + static lldb::clang_type_t + GetDirectBaseClassAtIndex (clang::ASTContext *ast, + lldb::clang_type_t clang_type, + uint32_t idx, + uint32_t *byte_offset_ptr); + + static lldb::clang_type_t + GetVirtualBaseClassAtIndex (clang::ASTContext *ast, + lldb::clang_type_t clang_type, + uint32_t idx, + uint32_t *byte_offset_ptr); + + static lldb::clang_type_t + GetFieldAtIndex (clang::ASTContext *ast, + lldb::clang_type_t clang_type, + uint32_t idx, + std::string& name, + uint32_t *byte_offset_ptr); + static uint32_t GetNumPointeeChildren (lldb::clang_type_t clang_type); diff --git a/lldb/include/lldb/Symbol/ClangASTType.h b/lldb/include/lldb/Symbol/ClangASTType.h index 9d256b77540d..841afd165986 100644 --- a/lldb/include/lldb/Symbol/ClangASTType.h +++ b/lldb/include/lldb/Symbol/ClangASTType.h @@ -107,6 +107,10 @@ public: GetMinimumLanguage (clang::ASTContext *ctx, lldb::clang_type_t clang_type); + static lldb::TypeClass + GetTypeClass (clang::ASTContext *ast_context, + lldb::clang_type_t clang_type); + void DumpValue (ExecutionContext *exe_ctx, Stream *s, diff --git a/lldb/include/lldb/Symbol/Type.h b/lldb/include/lldb/Symbol/Type.h index a35f1003034c..d228164776a8 100644 --- a/lldb/include/lldb/Symbol/Type.h +++ b/lldb/include/lldb/Symbol/Type.h @@ -390,6 +390,57 @@ public: private: std::vector m_content; }; + +class TypeMemberImpl +{ +public: + TypeMemberImpl () : + m_type_impl_sp (), + m_bit_offset (0), + m_name () + { + } + + TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp, + uint64_t bit_offset, + const ConstString &name) : + m_type_impl_sp (type_impl_sp), + m_bit_offset (bit_offset), + m_name (name) + { + } + + TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp, + uint64_t bit_offset): + m_type_impl_sp (type_impl_sp), + m_bit_offset (bit_offset), + m_name () + { + } + + const lldb::TypeImplSP & + GetTypeImpl () + { + return m_type_impl_sp; + } + + const ConstString & + GetName () const + { + return m_name; + } + + uint64_t + GetBitOffset () const + { + return m_bit_offset; + } + +protected: + lldb::TypeImplSP m_type_impl_sp; + uint64_t m_bit_offset; + ConstString m_name; +}; } // namespace lldb_private diff --git a/lldb/include/lldb/lldb-enumerations.h b/lldb/include/lldb/lldb-enumerations.h index 950796d67a06..704df80edf3c 100644 --- a/lldb/include/lldb/lldb-enumerations.h +++ b/lldb/include/lldb/lldb-enumerations.h @@ -550,7 +550,34 @@ namespace lldb { eBasicTypeObjCClass, eBasicTypeObjCSel } BasicType; - + + typedef enum TypeClass + { + eTypeClassInvalid = (0u), + eTypeClassArray = (1u << 0), + eTypeClassBlockPointer = (1u << 1), + eTypeClassBuiltin = (1u << 2), + eTypeClassClass = (1u << 3), + eTypeClassComplexFloat = (1u << 4), + eTypeClassComplexInteger = (1u << 5), + eTypeClassEnumeration = (1u << 6), + eTypeClassFunction = (1u << 7), + eTypeClassMemberPointer = (1u << 8), + eTypeClassObjCObject = (1u << 9), + eTypeClassObjCInterface = (1u << 10), + eTypeClassObjCObjectPointer = (1u << 11), + eTypeClassPointer = (1u << 12), + eTypeClassReference = (1u << 13), + eTypeClassStruct = (1u << 14), + eTypeClassTypedef = (1u << 15), + eTypeClassUnion = (1u << 16), + eTypeClassVector = (1u << 17), + // Define the last type class as the MSBit of a 32 bit value + eTypeClassOther = (1u << 31), + // Define a mask that can be used for any type when finding types + eTypeClassAny = (0xffffffffu) + }TypeClass; + } // namespace lldb diff --git a/lldb/include/lldb/lldb-forward.h b/lldb/include/lldb/lldb-forward.h index c07af33ce20d..ac155ff7798d 100644 --- a/lldb/include/lldb/lldb-forward.h +++ b/lldb/include/lldb/lldb-forward.h @@ -170,6 +170,7 @@ class TypeImpl; class TypeAndOrName; class TypeList; class TypeListImpl; +class TypeMemberImpl; class UUID; class Unwind; class UnwindAssembly; diff --git a/lldb/scripts/Python/interface/SBType.i b/lldb/scripts/Python/interface/SBType.i index 3086338d800e..ea20754e8f51 100644 --- a/lldb/scripts/Python/interface/SBType.i +++ b/lldb/scripts/Python/interface/SBType.i @@ -9,6 +9,35 @@ namespace lldb { + %feature("docstring", +"Represents a member of a type in lldb. +") SBTypeMember; + +class SBTypeMember +{ +public: + SBTypeMember (); + + SBTypeMember (const lldb::SBTypeMember& rhs); + + ~SBTypeMember(); + + bool + IsValid() const; + + const char * + GetName (); + + lldb::SBType + GetType (); + + uint64_t + GetOffsetByteSize(); + +protected: + std::auto_ptr m_opaque_ap; +}; + %feature("docstring", "Represents a data type in lldb. The FindFirstType() method of SBTarget/SBModule returns a SBType. @@ -85,39 +114,60 @@ find_type.py: class SBType { public: - SBType (const SBType &rhs); + SBType (const lldb::SBType &rhs); ~SBType (); bool - IsValid() const; + IsValid(); size_t - GetByteSize() const; + GetByteSize(); bool - IsPointerType() const; + IsPointerType(); bool - IsReferenceType() const; + IsReferenceType(); - SBType - GetPointerType() const; + lldb::SBType + GetPointerType(); - SBType - GetPointeeType() const; + lldb::SBType + GetPointeeType(); - SBType - GetReferenceType() const; + lldb::SBType + GetReferenceType(); - SBType - GetDereferencedType() const; + lldb::SBType + GetDereferencedType(); - SBType - GetBasicType(lldb::BasicType type) const; + lldb::SBType + GetBasicType (lldb::BasicType type); + + uint32_t + GetNumberOfFields (); + + uint32_t + GetNumberOfDirectBaseClasses (); + + uint32_t + GetNumberOfVirtualBaseClasses (); + + lldb::SBTypeMember + GetFieldAtIndex (uint32_t idx); + + lldb::SBTypeMember + GetDirectBaseClassAtIndex (uint32_t idx); + + lldb::SBTypeMember + GetVirtualBaseClassAtIndex (uint32_t idx); const char* GetName(); + + lldb::TypeClass + GetTypeClass (); }; %feature("docstring", @@ -157,15 +207,15 @@ public: SBTypeList(); bool - IsValid() const; + IsValid(); void - Append(const SBType& type); + Append (lldb::SBType type); - SBType - GetTypeAtIndex(int index); + lldb::SBType + GetTypeAtIndex (uint32_t index); - int + uint32_t GetSize(); ~SBTypeList(); diff --git a/lldb/scripts/Python/interface/SBValue.i b/lldb/scripts/Python/interface/SBValue.i index e87241070cbf..8792464b2451 100644 --- a/lldb/scripts/Python/interface/SBValue.i +++ b/lldb/scripts/Python/interface/SBValue.i @@ -65,7 +65,7 @@ public: ~SBValue (); bool - IsValid() const; + IsValid(); SBError GetError(); @@ -86,7 +86,7 @@ public: IsInScope (); lldb::Format - GetFormat () const; + GetFormat (); void SetFormat (lldb::Format format); @@ -185,21 +185,21 @@ public: bool can_create_synthetic); lldb::SBValue - CreateChildAtOffset (const char *name, uint32_t offset, const SBType& type); + CreateChildAtOffset (const char *name, uint32_t offset, lldb::SBType type); lldb::SBValue - SBValue::Cast(const SBType& type); + SBValue::Cast (lldb::SBType type); lldb::SBValue CreateValueFromExpression (const char *name, const char* expression); lldb::SBValue - CreateValueFromAddress(const char* name, lldb::addr_t address, const SBType& type); + CreateValueFromAddress(const char* name, lldb::addr_t address, lldb::SBType type); lldb::SBValue CreateValueFromData (const char* name, - const SBData& data, - const SBType& type); + lldb::SBData data, + lldb::SBType type); lldb::SBType GetType(); diff --git a/lldb/source/API/SBFrame.cpp b/lldb/source/API/SBFrame.cpp index 4174638b8e7f..3f27b6fc123f 100644 --- a/lldb/source/API/SBFrame.cpp +++ b/lldb/source/API/SBFrame.cpp @@ -538,8 +538,8 @@ SBFrame::get() const return m_opaque_sp.get(); } -const lldb::StackFrameSP & -SBFrame::get_sp() const +lldb::StackFrameSP & +SBFrame::get_sp() { return m_opaque_sp; } diff --git a/lldb/source/API/SBType.cpp b/lldb/source/API/SBType.cpp index 582eceec1e32..8deb01c50afc 100644 --- a/lldb/source/API/SBType.cpp +++ b/lldb/source/API/SBType.cpp @@ -31,7 +31,7 @@ SBType::SBType() : { } -SBType::SBType (const lldb_private::ClangASTType &type) : +SBType::SBType (const ClangASTType &type) : m_opaque_sp(new TypeImpl(ClangASTType(type.GetASTContext(), type.GetOpaqueQualType()))) { @@ -63,7 +63,7 @@ SBType::SBType (const SBType &rhs) : //{} // bool -SBType::operator == (const lldb::SBType &rhs) const +SBType::operator == (SBType &rhs) { if (IsValid() == false) return !rhs.IsValid(); @@ -73,7 +73,7 @@ SBType::operator == (const lldb::SBType &rhs) const } bool -SBType::operator != (const lldb::SBType &rhs) const +SBType::operator != (SBType &rhs) { if (IsValid() == false) return rhs.IsValid(); @@ -82,11 +82,16 @@ SBType::operator != (const lldb::SBType &rhs) const (rhs.m_opaque_sp->GetOpaqueQualType() != m_opaque_sp->GetOpaqueQualType()); } - -const lldb::SBType & -SBType::operator = (const lldb::SBType &rhs) +void +SBType::reset(const lldb::TypeImplSP &type_impl_sp) { - if (*this != rhs) + m_opaque_sp = type_impl_sp; +} + +SBType & +SBType::operator = (const SBType &rhs) +{ + if (this != &rhs) { m_opaque_sp = rhs.m_opaque_sp; } @@ -96,15 +101,15 @@ SBType::operator = (const lldb::SBType &rhs) SBType::~SBType () {} -lldb_private::TypeImpl & +TypeImpl & SBType::ref () { if (m_opaque_sp.get() == NULL) - m_opaque_sp.reset (new lldb_private::TypeImpl()); + m_opaque_sp.reset (new TypeImpl()); return *m_opaque_sp; } -const lldb_private::TypeImpl & +const TypeImpl & SBType::ref () const { // "const SBAddress &addr" should already have checked "addr.IsValid()" @@ -124,7 +129,7 @@ SBType::IsValid() const } size_t -SBType::GetByteSize() const +SBType::GetByteSize() { if (!IsValid()) return 0; @@ -134,7 +139,7 @@ SBType::GetByteSize() const } bool -SBType::IsPointerType() const +SBType::IsPointerType() { if (!IsValid()) return false; @@ -148,7 +153,7 @@ SBType::IsPointerType() const } bool -SBType::IsReferenceType() const +SBType::IsReferenceType() { if (!IsValid()) return false; @@ -162,7 +167,7 @@ SBType::IsReferenceType() const } SBType -SBType::GetPointerType() const +SBType::GetPointerType() { if (!IsValid()) return SBType(); @@ -172,7 +177,7 @@ SBType::GetPointerType() const } SBType -SBType::GetPointeeType() const +SBType::GetPointeeType() { if (!IsValid()) return SBType(); @@ -186,7 +191,7 @@ SBType::GetPointeeType() const } SBType -SBType::GetReferenceType() const +SBType::GetReferenceType() { if (!IsValid()) return SBType(); @@ -196,7 +201,7 @@ SBType::GetReferenceType() const } SBType -SBType::GetDereferencedType() const +SBType::GetDereferencedType() { if (!IsValid()) return SBType(); @@ -207,7 +212,7 @@ SBType::GetDereferencedType() const } SBType -SBType::GetBasicType(lldb::BasicType type) const +SBType::GetBasicType(lldb::BasicType type) { if (!IsValid()) @@ -302,6 +307,89 @@ SBType::GetBasicType(lldb::BasicType type) const return SBType(ClangASTType(m_opaque_sp->GetASTContext(), base_type_qual.getAsOpaquePtr())); } +uint32_t +SBType::GetNumberOfDirectBaseClasses () +{ + if (IsValid()) + return ClangASTContext::GetNumDirectBaseClasses(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType()); + return 0; +} + +uint32_t +SBType::GetNumberOfVirtualBaseClasses () +{ + if (IsValid()) + return ClangASTContext::GetNumVirtualBaseClasses(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType()); + return 0; +} + +uint32_t +SBType::GetNumberOfFields () +{ + if (IsValid()) + return ClangASTContext::GetNumFields(m_opaque_sp->GetASTContext(), m_opaque_sp->GetOpaqueQualType()); + return 0; +} + +SBTypeMember +SBType::GetDirectBaseClassAtIndex (uint32_t idx) +{ + SBTypeMember sb_type_member; + if (IsValid()) + { + clang::ASTContext* ast = m_opaque_sp->GetASTContext(); + uint32_t byte_offset = 0; + clang_type_t clang_type = ClangASTContext::GetDirectBaseClassAtIndex (ast, m_opaque_sp->GetOpaqueQualType(), idx, &byte_offset); + if (clang_type) + { + TypeImplSP type_impl_sp (new TypeImpl(ClangASTType (ast, clang_type))); + sb_type_member.reset (new TypeMemberImpl (type_impl_sp, byte_offset)); + } + } + return sb_type_member; + +} + +SBTypeMember +SBType::GetVirtualBaseClassAtIndex (uint32_t idx) +{ + SBTypeMember sb_type_member; + if (IsValid()) + { + uint32_t byte_offset = 0; + clang::ASTContext* ast = m_opaque_sp->GetASTContext(); + clang_type_t clang_type = ClangASTContext::GetVirtualBaseClassAtIndex (ast, m_opaque_sp->GetOpaqueQualType(), idx, &byte_offset); + if (clang_type) + { + TypeImplSP type_impl_sp (new TypeImpl(ClangASTType (ast, clang_type))); + sb_type_member.reset (new TypeMemberImpl (type_impl_sp, byte_offset)); + } + } + return sb_type_member; +} + +SBTypeMember +SBType::GetFieldAtIndex (uint32_t idx) +{ + SBTypeMember sb_type_member; + if (IsValid()) + { + uint32_t byte_offset = 0; + clang::ASTContext* ast = m_opaque_sp->GetASTContext(); + std::string name_sstr; + clang_type_t clang_type = ClangASTContext::GetFieldAtIndex (ast, m_opaque_sp->GetOpaqueQualType(), idx, name_sstr, &byte_offset); + if (clang_type) + { + ConstString name; + if (!name_sstr.empty()) + name.SetCString(name_sstr.c_str()); + TypeImplSP type_impl_sp (new TypeImpl(ClangASTType (ast, clang_type))); + sb_type_member.reset (new TypeMemberImpl (type_impl_sp, byte_offset, name)); + } + } + return sb_type_member; +} + const char* SBType::GetName() { @@ -311,6 +399,15 @@ SBType::GetName() return ClangASTType::GetConstTypeName(m_opaque_sp->GetOpaqueQualType()).GetCString(); } +lldb::TypeClass +SBType::GetTypeClass () +{ + if (IsValid()) + return ClangASTType::GetTypeClass (m_opaque_sp->GetASTContext(), + m_opaque_sp->GetOpaqueQualType()); + return lldb::eTypeClassInvalid; +} + SBTypeList::SBTypeList() : m_opaque_ap(new TypeListImpl()) { @@ -319,12 +416,12 @@ SBTypeList::SBTypeList() : SBTypeList::SBTypeList(const SBTypeList& rhs) : m_opaque_ap(new TypeListImpl()) { - for (uint32_t i = 0, rhs_size = rhs.GetSize(); i < rhs_size; i++) - Append(rhs.GetTypeAtIndex(i)); + for (uint32_t i = 0, rhs_size = const_cast(rhs).GetSize(); i < rhs_size; i++) + Append(const_cast(rhs).GetTypeAtIndex(i)); } bool -SBTypeList::IsValid () const +SBTypeList::IsValid () { return (m_opaque_ap.get() != NULL); } @@ -332,30 +429,32 @@ SBTypeList::IsValid () const SBTypeList& SBTypeList::operator = (const SBTypeList& rhs) { - if (this != &rhs && m_opaque_ap.get() != rhs.m_opaque_ap.get()) + if (this != &rhs) { - m_opaque_ap.reset(new TypeListImpl()); - for (uint32_t i = 0, rhs_size = rhs.GetSize(); i < rhs_size; i++) - Append(rhs.GetTypeAtIndex(i)); + m_opaque_ap.reset (new TypeListImpl()); + for (uint32_t i = 0, rhs_size = const_cast(rhs).GetSize(); i < rhs_size; i++) + Append(const_cast(rhs).GetTypeAtIndex(i)); } return *this; } void -SBTypeList::Append (const SBType& type) +SBTypeList::Append (SBType type) { if (type.IsValid()) m_opaque_ap->Append (type.m_opaque_sp); } SBType -SBTypeList::GetTypeAtIndex(int index) const +SBTypeList::GetTypeAtIndex(uint32_t index) { - return SBType(m_opaque_ap->GetTypeAtIndex(index)); + if (m_opaque_ap.get()) + return SBType(m_opaque_ap->GetTypeAtIndex(index)); + return SBType(); } -int -SBTypeList::GetSize() const +uint32_t +SBTypeList::GetSize() { return m_opaque_ap->GetSize(); } @@ -367,7 +466,7 @@ SBTypeList::~SBTypeList() bool SBType::IsPointerType (void *opaque_type) { - LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); + LogSP log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); bool ret_value = ClangASTContext::IsPointerType (opaque_type); @@ -376,3 +475,89 @@ SBType::IsPointerType (void *opaque_type) return ret_value; } + + +SBTypeMember::SBTypeMember() : + m_opaque_ap() +{ +} + +SBTypeMember::~SBTypeMember() +{ +} + +SBTypeMember::SBTypeMember (const SBTypeMember& rhs) : + m_opaque_ap() +{ + if (this != &rhs) + { + if (rhs.IsValid()) + m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); + } +} + +lldb::SBTypeMember& +SBTypeMember::operator = (const lldb::SBTypeMember& rhs) +{ + if (this != &rhs) + { + if (rhs.IsValid()) + m_opaque_ap.reset(new TypeMemberImpl(rhs.ref())); + } + return *this; +} + +bool +SBTypeMember::IsValid() const +{ + return m_opaque_ap.get(); +} + +const char * +SBTypeMember::GetName () +{ + if (m_opaque_ap.get()) + return m_opaque_ap->GetName().GetCString(); + return NULL; +} + +SBType +SBTypeMember::GetType () +{ + SBType sb_type; + if (m_opaque_ap.get()) + { + sb_type.reset (m_opaque_ap->GetTypeImpl()); + } + return sb_type; + +} + +uint64_t +SBTypeMember::GetOffsetByteSize() +{ + if (m_opaque_ap.get()) + return (m_opaque_ap->GetBitOffset() + 7) / 8u; + return 0; +} + +void +SBTypeMember::reset(TypeMemberImpl *type_member_impl) +{ + m_opaque_ap.reset(type_member_impl); +} + +TypeMemberImpl & +SBTypeMember::ref () +{ + if (m_opaque_ap.get() == NULL) + m_opaque_ap.reset (new TypeMemberImpl()); + return *m_opaque_ap.get(); +} + +const TypeMemberImpl & +SBTypeMember::ref () const +{ + return *m_opaque_ap.get(); +} + diff --git a/lldb/source/API/SBValue.cpp b/lldb/source/API/SBValue.cpp index ea7ebf8c13eb..d0e2e6787936 100644 --- a/lldb/source/API/SBValue.cpp +++ b/lldb/source/API/SBValue.cpp @@ -52,7 +52,7 @@ SBValue::SBValue(const SBValue &rhs) : { } -const SBValue & +SBValue & SBValue::operator = (const SBValue &rhs) { if (this != &rhs) @@ -65,7 +65,7 @@ SBValue::~SBValue() } bool -SBValue::IsValid () const +SBValue::IsValid () { // If this function ever changes to anything that does more than just // check if the opaque shared pointer is non NULL, then we need to update @@ -145,12 +145,6 @@ SBValue::GetByteSize () return result; } -bool -SBValue::IsInScope (const SBFrame &sb_frame) -{ - return IsInScope(); -} - bool SBValue::IsInScope () { @@ -172,12 +166,6 @@ SBValue::IsInScope () return result; } -const char * -SBValue::GetValue (const SBFrame &sb_frame) -{ - return GetValue(); -} - const char * SBValue::GetValue () { @@ -227,12 +215,6 @@ SBValue::GetValueType () return result; } -const char * -SBValue::GetObjectDescription (const SBFrame &sb_frame) -{ - return GetObjectDescription (); -} - const char * SBValue::GetObjectDescription () { @@ -256,12 +238,6 @@ SBValue::GetObjectDescription () return cstr; } -bool -SBValue::GetValueDidChange (const SBFrame &sb_frame) -{ - return GetValueDidChange (); -} - SBType SBValue::GetType() { @@ -304,12 +280,6 @@ SBValue::GetValueDidChange () return result; } -const char * -SBValue::GetSummary (const SBFrame &sb_frame) -{ - return GetSummary (); -} - const char * SBValue::GetSummary () { @@ -333,12 +303,6 @@ SBValue::GetSummary () return cstr; } -const char * -SBValue::GetLocation (const SBFrame &sb_frame) -{ - return GetLocation (); -} - const char * SBValue::GetLocation () { @@ -362,12 +326,6 @@ SBValue::GetLocation () return cstr; } -bool -SBValue::SetValueFromCString (const SBFrame &sb_frame, const char *value_str) -{ - return SetValueFromCString (value_str); -} - bool SBValue::SetValueFromCString (const char *value_str) { @@ -384,7 +342,7 @@ SBValue::SetValueFromCString (const char *value_str) } lldb::SBValue -SBValue::CreateChildAtOffset (const char *name, uint32_t offset, const SBType& type) +SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type) { lldb::SBValue result; if (m_opaque_sp) @@ -407,7 +365,7 @@ SBValue::CreateChildAtOffset (const char *name, uint32_t offset, const SBType& t } lldb::SBValue -SBValue::Cast(const SBType& type) +SBValue::Cast (SBType type) { return CreateChildAtOffset(m_opaque_sp->GetName().GetCString(), 0, type); } @@ -419,10 +377,10 @@ SBValue::CreateValueFromExpression (const char *name, const char* expression) if (m_opaque_sp) { ValueObjectSP result_valobj_sp; - m_opaque_sp->GetUpdatePoint().GetTargetSP()->EvaluateExpression(expression, - m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame(), - true, true, eNoDynamicValues, - result_valobj_sp); + m_opaque_sp->GetUpdatePoint().GetTargetSP()->EvaluateExpression (expression, + m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame(), + true, true, eNoDynamicValues, + result_valobj_sp); result_valobj_sp->SetName(ConstString(name)); result = SBValue(result_valobj_sp); } @@ -438,7 +396,7 @@ SBValue::CreateValueFromExpression (const char *name, const char* expression) } lldb::SBValue -SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, const SBType& type) +SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType type) { lldb::SBValue result; if (m_opaque_sp) @@ -448,13 +406,13 @@ SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, const SB lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t))); - ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope(), - real_type.m_opaque_sp->GetASTContext(), - real_type.m_opaque_sp->GetOpaqueQualType(), - ConstString(name), - buffer, - lldb::endian::InlHostByteOrder(), - GetTarget().GetProcess().GetAddressByteSize())); + ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope(), + real_type.m_opaque_sp->GetASTContext(), + real_type.m_opaque_sp->GetOpaqueQualType(), + ConstString(name), + buffer, + lldb::endian::InlHostByteOrder(), + GetTarget().GetProcess().GetAddressByteSize())); ValueObjectSP result_valobj_sp; @@ -480,9 +438,7 @@ SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, const SB } lldb::SBValue -SBValue::CreateValueFromData (const char* name, - const SBData& data, - const SBType& type) +SBValue::CreateValueFromData (const char* name, SBData data, SBType type) { SBValue result; @@ -869,7 +825,7 @@ SBValue::GetThread() { if (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()) { - result = SBThread(lldb::ThreadSP(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateThread())); + result = SBThread(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateThread()->GetSP()); } } LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); @@ -891,7 +847,7 @@ SBValue::GetFrame() { if (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()) { - result = SBFrame(lldb::StackFrameSP(m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame())); + result.SetFrame (m_opaque_sp->GetUpdatePoint().GetExecutionContextScope()->CalculateStackFrame()->GetSP()); } } LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); @@ -980,7 +936,7 @@ SBValue::GetDescription (SBStream &description) } lldb::Format -SBValue::GetFormat () const +SBValue::GetFormat () { if (m_opaque_sp) return m_opaque_sp->GetFormat(); diff --git a/lldb/source/Symbol/ClangASTContext.cpp b/lldb/source/Symbol/ClangASTContext.cpp index 382133a78d85..1c0ec1baf092 100644 --- a/lldb/source/Symbol/ClangASTContext.cpp +++ b/lldb/source/Symbol/ClangASTContext.cpp @@ -2397,6 +2397,386 @@ ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type return num_children; } +uint32_t +ClangASTContext::GetNumDirectBaseClasses (clang::ASTContext *ast, clang_type_t clang_type) +{ + if (clang_type == NULL) + return 0; + + uint32_t count = 0; + QualType qual_type(QualType::getFromOpaquePtr(clang_type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + if (GetCompleteQualType (ast, qual_type)) + { + const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + count = cxx_record_decl->getNumBases(); + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteQualType (ast, qual_type)) + { + const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); + if (objc_class_type) + { + ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + + if (class_interface_decl && class_interface_decl->getSuperClass()) + count = 1; + } + } + break; + + + case clang::Type::Typedef: + count = ClangASTContext::GetNumDirectBaseClasses (ast, cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); + break; + + case clang::Type::Elaborated: + count = ClangASTContext::GetNumDirectBaseClasses (ast, cast(qual_type)->getNamedType().getAsOpaquePtr()); + break; + + default: + break; + } + return count; +} + +uint32_t +ClangASTContext::GetNumVirtualBaseClasses (clang::ASTContext *ast, + clang_type_t clang_type) +{ + if (clang_type == NULL) + return 0; + + uint32_t count = 0; + QualType qual_type(QualType::getFromOpaquePtr(clang_type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + if (GetCompleteQualType (ast, qual_type)) + { + const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + count = cxx_record_decl->getNumVBases(); + } + break; + + case clang::Type::Typedef: + count = ClangASTContext::GetNumVirtualBaseClasses (ast, cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); + break; + + case clang::Type::Elaborated: + count = ClangASTContext::GetNumVirtualBaseClasses (ast, cast(qual_type)->getNamedType().getAsOpaquePtr()); + break; + + default: + break; + } + return count; +} + +uint32_t +ClangASTContext::GetNumFields (clang::ASTContext *ast, clang_type_t clang_type) +{ + if (clang_type == NULL) + return 0; + + uint32_t count = 0; + QualType qual_type(QualType::getFromOpaquePtr(clang_type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + if (GetCompleteQualType (ast, qual_type)) + { + const RecordType *record_type = dyn_cast(qual_type.getTypePtr()); + if (record_type) + { + RecordDecl *record_decl = record_type->getDecl(); + if (record_decl) + { + uint32_t field_idx = 0; + RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) + ++field_idx; + count = field_idx; + } + } + } + break; + + case clang::Type::Typedef: + count = ClangASTContext::GetNumFields (ast, cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()); + break; + + case clang::Type::Elaborated: + count = ClangASTContext::GetNumFields (ast, cast(qual_type)->getNamedType().getAsOpaquePtr()); + break; + + default: + break; + } + return count; +} + +clang_type_t +ClangASTContext::GetDirectBaseClassAtIndex (clang::ASTContext *ast, + clang_type_t clang_type, + uint32_t idx, + uint32_t *byte_offset_ptr) +{ + if (clang_type == NULL) + return 0; + + QualType qual_type(QualType::getFromOpaquePtr(clang_type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + if (GetCompleteQualType (ast, qual_type)) + { + const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + { + uint32_t curr_idx = 0; + CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; + ++base_class, ++curr_idx) + { + if (curr_idx == idx) + { + if (byte_offset_ptr) + { + const ASTRecordLayout &record_layout = ast->getASTRecordLayout(cxx_record_decl); + const CXXRecordDecl *base_class_decl = cast(base_class->getType()->getAs()->getDecl()); +// if (base_class->isVirtual()) +// *byte_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; +// else + *byte_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; + } + return base_class->getType().getAsOpaquePtr(); + } + } + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (idx == 0 && GetCompleteQualType (ast, qual_type)) + { + const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); + if (objc_class_type) + { + ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + + if (class_interface_decl) + { + ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); + if (superclass_interface_decl) + { + if (byte_offset_ptr) + *byte_offset_ptr = 0; + return ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(); + } + } + } + } + break; + + + case clang::Type::Typedef: + return ClangASTContext::GetDirectBaseClassAtIndex (ast, + cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), + idx, + byte_offset_ptr); + + case clang::Type::Elaborated: + return ClangASTContext::GetDirectBaseClassAtIndex (ast, + cast(qual_type)->getNamedType().getAsOpaquePtr(), + idx, + byte_offset_ptr); + + default: + break; + } + return NULL; +} + +clang_type_t +ClangASTContext::GetVirtualBaseClassAtIndex (clang::ASTContext *ast, + clang_type_t clang_type, + uint32_t idx, + uint32_t *byte_offset_ptr) +{ + if (clang_type == NULL) + return 0; + + QualType qual_type(QualType::getFromOpaquePtr(clang_type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + if (GetCompleteQualType (ast, qual_type)) + { + const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); + if (cxx_record_decl) + { + uint32_t curr_idx = 0; + CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end(); + base_class != base_class_end; + ++base_class, ++curr_idx) + { + if (curr_idx == idx) + { + if (byte_offset_ptr) + { + const ASTRecordLayout &record_layout = ast->getASTRecordLayout(cxx_record_decl); + const CXXRecordDecl *base_class_decl = cast(base_class->getType()->getAs()->getDecl()); + *byte_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; + + } + return base_class->getType().getAsOpaquePtr(); + } + } + } + } + break; + + case clang::Type::Typedef: + return ClangASTContext::GetVirtualBaseClassAtIndex (ast, + cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), + idx, + byte_offset_ptr); + + case clang::Type::Elaborated: + return ClangASTContext::GetVirtualBaseClassAtIndex (ast, + cast(qual_type)->getNamedType().getAsOpaquePtr(), + idx, + byte_offset_ptr); + + default: + break; + } + return NULL; +} + +clang_type_t +ClangASTContext::GetFieldAtIndex (clang::ASTContext *ast, + clang_type_t clang_type, + uint32_t idx, + std::string& name, + uint32_t *byte_offset_ptr) +{ + if (clang_type == NULL) + return 0; + + QualType qual_type(QualType::getFromOpaquePtr(clang_type)); + const clang::Type::TypeClass type_class = qual_type->getTypeClass(); + switch (type_class) + { + case clang::Type::Record: + if (GetCompleteQualType (ast, qual_type)) + { + const RecordType *record_type = cast(qual_type.getTypePtr()); + const RecordDecl *record_decl = record_type->getDecl(); + uint32_t field_idx = 0; + RecordDecl::field_iterator field, field_end; + for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx) + { + if (idx == field_idx) + { + // Print the member type if requested + // Print the member name and equal sign + name.assign(field->getNameAsString()); + + // Figure out the type byte size (field_type_info.first) and + // alignment (field_type_info.second) from the AST context. + if (byte_offset_ptr) + { + const ASTRecordLayout &record_layout = ast->getASTRecordLayout(record_decl); + *byte_offset_ptr = (record_layout.getFieldOffset (field_idx) + 7) / 8; + } + + return field->getType().getAsOpaquePtr(); + } + } + } + break; + + case clang::Type::ObjCObject: + case clang::Type::ObjCInterface: + if (GetCompleteQualType (ast, qual_type)) + { + const ObjCObjectType *objc_class_type = dyn_cast(qual_type.getTypePtr()); + assert (objc_class_type); + if (objc_class_type) + { + ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); + + if (class_interface_decl) + { + if (idx < (class_interface_decl->ivar_size())) + { + ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); + uint32_t ivar_idx = 0; + + for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx) + { + if (ivar_idx == idx) + { + const ObjCIvarDecl* ivar_decl = *ivar_pos; + + QualType ivar_qual_type(ivar_decl->getType()); + + name.assign(ivar_decl->getNameAsString()); + + if (byte_offset_ptr) + { + const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl); + *byte_offset_ptr = (interface_layout.getFieldOffset (ivar_idx) + 7)/8; + } + + return ivar_qual_type.getAsOpaquePtr(); + } + } + } + } + } + } + break; + + + case clang::Type::Typedef: + return ClangASTContext::GetFieldAtIndex (ast, + cast(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), + idx, + name, + byte_offset_ptr); + + case clang::Type::Elaborated: + return ClangASTContext::GetFieldAtIndex (ast, + cast(qual_type)->getNamedType().getAsOpaquePtr(), + idx, + name, + byte_offset_ptr); + + default: + break; + } + return NULL; +} + + // If a pointer to a pointee type (the clang_type arg) says that it has no // children, then we either need to trust it, or override it and return a // different result. For example, an "int *" has one child that is an integer, @@ -2616,7 +2996,6 @@ ClangASTContext::GetChildClangTypeAtIndex bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; // Base classes should be a multiple of 8 bits in size - assert (bit_offset % 8 == 0); child_byte_offset = bit_offset/8; child_name = ClangASTType::GetTypeNameForQualType(base_class->getType()); diff --git a/lldb/source/Symbol/ClangASTType.cpp b/lldb/source/Symbol/ClangASTType.cpp index 931bd5e72732..f383323d583f 100644 --- a/lldb/source/Symbol/ClangASTType.cpp +++ b/lldb/source/Symbol/ClangASTType.cpp @@ -215,6 +215,79 @@ ClangASTType::GetMinimumLanguage () m_type); } +lldb::TypeClass +ClangASTType::GetTypeClass (clang::ASTContext *ast_context, lldb::clang_type_t clang_type) +{ + if (clang_type == NULL) + return lldb::eTypeClassInvalid; + + clang::QualType qual_type(clang::QualType::getFromOpaquePtr(clang_type)); + + switch (qual_type->getTypeClass()) + { + case clang::Type::UnaryTransform: break; + case clang::Type::FunctionNoProto: return lldb::eTypeClassFunction; + case clang::Type::FunctionProto: return lldb::eTypeClassFunction; + case clang::Type::IncompleteArray: return lldb::eTypeClassArray; + case clang::Type::VariableArray: return lldb::eTypeClassArray; + case clang::Type::ConstantArray: return lldb::eTypeClassArray; + case clang::Type::DependentSizedArray: return lldb::eTypeClassArray; + case clang::Type::DependentSizedExtVector: return lldb::eTypeClassVector; + case clang::Type::ExtVector: return lldb::eTypeClassVector; + case clang::Type::Vector: return lldb::eTypeClassVector; + case clang::Type::Builtin: return lldb::eTypeClassBuiltin; + case clang::Type::ObjCObjectPointer: return lldb::eTypeClassObjCObjectPointer; + case clang::Type::BlockPointer: return lldb::eTypeClassBlockPointer; + case clang::Type::Pointer: return lldb::eTypeClassPointer; + case clang::Type::LValueReference: return lldb::eTypeClassReference; + case clang::Type::RValueReference: return lldb::eTypeClassReference; + case clang::Type::MemberPointer: return lldb::eTypeClassMemberPointer; + case clang::Type::Complex: + if (qual_type->isComplexType()) + return lldb::eTypeClassComplexFloat; + else + return lldb::eTypeClassComplexInteger; + case clang::Type::ObjCObject: return lldb::eTypeClassObjCObject; + case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface; + case clang::Type::Record: + if (ClangASTContext::GetCompleteType (ast_context, clang_type)) + { + const clang::RecordType *record_type = llvm::cast(qual_type.getTypePtr()); + const clang::RecordDecl *record_decl = record_type->getDecl(); + if (record_decl->isUnion()) + return lldb::eTypeClassUnion; + else if (record_decl->isStruct()) + return lldb::eTypeClassStruct; + else + return lldb::eTypeClassClass; + } + break; + case clang::Type::Enum: return lldb::eTypeClassEnumeration; + case clang::Type::Typedef: return lldb::eTypeClassTypedef; + case clang::Type::UnresolvedUsing: break; + case clang::Type::Paren: break; + case clang::Type::Elaborated: break; + case clang::Type::Attributed: break; + case clang::Type::TemplateTypeParm: break; + case clang::Type::SubstTemplateTypeParm: break; + case clang::Type::SubstTemplateTypeParmPack:break; + case clang::Type::Auto: break; + case clang::Type::InjectedClassName: break; + case clang::Type::DependentName: break; + case clang::Type::DependentTemplateSpecialization: break; + case clang::Type::PackExpansion: break; + + case clang::Type::TypeOfExpr: break; + case clang::Type::TypeOf: break; + case clang::Type::Decltype: break; + case clang::Type::TemplateSpecialization: break; + } + // We don't know hot to display this type... + return lldb::eTypeClassOther; + +} + + lldb::LanguageType ClangASTType::GetMinimumLanguage (clang::ASTContext *ctx, lldb::clang_type_t clang_type)