1 //===-- SBType.cpp ----------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/API/SBDefines.h"
11 #include "lldb/API/SBType.h"
12 #include "lldb/API/SBTypeEnumMember.h"
13 #include "lldb/API/SBStream.h"
14 #include "lldb/Core/ConstString.h"
15 #include "lldb/Core/Log.h"
16 #include "lldb/Core/Mangled.h"
17 #include "lldb/Core/Stream.h"
18 #include "lldb/Symbol/CompilerType.h"
19 #include "lldb/Symbol/Type.h"
20 #include "lldb/Symbol/TypeSystem.h"
22 #include "llvm/ADT/APSInt.h"
25 using namespace lldb_private;
32 SBType::SBType (const CompilerType &type) :
33 m_opaque_sp(new TypeImpl(CompilerType(type.GetTypeSystem(),
34 type.GetOpaqueQualType())))
38 SBType::SBType (const lldb::TypeSP &type_sp) :
39 m_opaque_sp(new TypeImpl(type_sp))
43 SBType::SBType (const lldb::TypeImplSP &type_impl_sp) :
44 m_opaque_sp(type_impl_sp)
49 SBType::SBType (const SBType &rhs) :
54 m_opaque_sp = rhs.m_opaque_sp;
59 //SBType::SBType (TypeImpl* impl) :
64 SBType::operator == (SBType &rhs)
66 if (IsValid() == false)
67 return !rhs.IsValid();
69 if (rhs.IsValid() == false)
72 return *m_opaque_sp.get() == *rhs.m_opaque_sp.get();
76 SBType::operator != (SBType &rhs)
78 if (IsValid() == false)
81 if (rhs.IsValid() == false)
84 return *m_opaque_sp.get() != *rhs.m_opaque_sp.get();
95 SBType::SetSP (const lldb::TypeImplSP &type_impl_sp)
97 m_opaque_sp = type_impl_sp;
101 SBType::operator = (const SBType &rhs)
105 m_opaque_sp = rhs.m_opaque_sp;
116 if (m_opaque_sp.get() == NULL)
117 m_opaque_sp.reset (new TypeImpl());
124 // "const SBAddress &addr" should already have checked "addr.IsValid()"
125 // prior to calling this function. In case you didn't we will assert
126 // and die to let you know.
127 assert (m_opaque_sp.get());
132 SBType::IsValid() const
134 if (m_opaque_sp.get() == NULL)
137 return m_opaque_sp->IsValid();
141 SBType::GetByteSize()
146 return m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr);
151 SBType::IsPointerType()
155 return m_opaque_sp->GetCompilerType(true).IsPointerType();
159 SBType::IsArrayType()
163 return m_opaque_sp->GetCompilerType(true).IsArrayType(nullptr, nullptr, nullptr);
167 SBType::IsVectorType()
171 return m_opaque_sp->GetCompilerType(true).IsVectorType(nullptr, nullptr);
175 SBType::IsReferenceType()
179 return m_opaque_sp->GetCompilerType(true).IsReferenceType();
183 SBType::GetPointerType()
188 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())));
192 SBType::GetPointeeType()
196 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())));
200 SBType::GetReferenceType()
204 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())));
208 SBType::GetTypedefedType()
212 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())));
216 SBType::GetDereferencedType()
220 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())));
224 SBType::GetArrayElementType()
228 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCompilerType(true).GetArrayElementType())));
232 SBType::GetVectorElementType ()
237 CompilerType vector_element_type;
238 if (m_opaque_sp->GetCompilerType(true).IsVectorType(&vector_element_type, nullptr))
239 type_sb.SetSP(TypeImplSP(new TypeImpl(vector_element_type)));
245 SBType::IsFunctionType ()
249 return m_opaque_sp->GetCompilerType(true).IsFunctionType();
253 SBType::IsPolymorphicClass ()
257 return m_opaque_sp->GetCompilerType(true).IsPolymorphicClass();
261 SBType::IsTypedefType ()
265 return m_opaque_sp->GetCompilerType(true).IsTypedefType();
269 SBType::IsAnonymousType ()
273 return m_opaque_sp->GetCompilerType(true).IsAnonymousType();
277 SBType::GetFunctionReturnType ()
281 CompilerType return_type (m_opaque_sp->GetCompilerType(true).GetFunctionReturnType());
282 if (return_type.IsValid())
283 return SBType(return_type);
285 return lldb::SBType();
289 SBType::GetFunctionArgumentTypes ()
291 SBTypeList sb_type_list;
294 CompilerType func_type(m_opaque_sp->GetCompilerType(true));
295 size_t count = func_type.GetNumberOfFunctionArguments();
300 sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i)));
307 SBType::GetNumberOfMemberFunctions ()
311 return m_opaque_sp->GetCompilerType(true).GetNumMemberFunctions();
316 lldb::SBTypeMemberFunction
317 SBType::GetMemberFunctionAtIndex (uint32_t idx)
319 SBTypeMemberFunction sb_func_type;
321 sb_func_type.reset(new TypeMemberFunctionImpl(m_opaque_sp->GetCompilerType(true).GetMemberFunctionAtIndex(idx)));
326 SBType::GetUnqualifiedType()
330 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())));
334 SBType::GetCanonicalType()
337 return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
343 SBType::GetBasicType()
346 return m_opaque_sp->GetCompilerType(false).GetBasicTypeEnumeration ();
347 return eBasicTypeInvalid;
351 SBType::GetBasicType(lldb::BasicType basic_type)
353 if (IsValid() && m_opaque_sp->IsValid())
354 return SBType(m_opaque_sp->GetTypeSystem(false)->GetBasicTypeFromAST(basic_type));
359 SBType::GetNumberOfDirectBaseClasses ()
362 return m_opaque_sp->GetCompilerType(true).GetNumDirectBaseClasses();
367 SBType::GetNumberOfVirtualBaseClasses ()
370 return m_opaque_sp->GetCompilerType(true).GetNumVirtualBaseClasses();
375 SBType::GetNumberOfFields ()
378 return m_opaque_sp->GetCompilerType(true).GetNumFields();
383 SBType::GetDescription (SBStream &description, lldb::DescriptionLevel description_level)
385 Stream &strm = description.ref();
389 m_opaque_sp->GetDescription (strm, description_level);
392 strm.PutCString ("No value");
400 SBType::GetDirectBaseClassAtIndex (uint32_t idx)
402 SBTypeMember sb_type_member;
405 uint32_t bit_offset = 0;
406 CompilerType base_class_type = m_opaque_sp->GetCompilerType (true).GetDirectBaseClassAtIndex(idx, &bit_offset);
407 if (base_class_type.IsValid())
408 sb_type_member.reset (new TypeMemberImpl (TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
410 return sb_type_member;
415 SBType::GetVirtualBaseClassAtIndex (uint32_t idx)
417 SBTypeMember sb_type_member;
420 uint32_t bit_offset = 0;
421 CompilerType base_class_type = m_opaque_sp->GetCompilerType (true).GetVirtualBaseClassAtIndex(idx, &bit_offset);
422 if (base_class_type.IsValid())
423 sb_type_member.reset (new TypeMemberImpl (TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
425 return sb_type_member;
429 SBType::GetEnumMembers ()
431 SBTypeEnumMemberList sb_enum_member_list;
434 CompilerType this_type (m_opaque_sp->GetCompilerType (true));
435 if (this_type.IsValid())
437 this_type.ForEachEnumerator([&sb_enum_member_list] (const CompilerType &integer_type, const ConstString &name, const llvm::APSInt &value) -> bool {
438 SBTypeEnumMember enum_member (lldb::TypeEnumMemberImplSP (new TypeEnumMemberImpl(lldb::TypeImplSP(new TypeImpl(integer_type)), name, value)));
439 sb_enum_member_list.Append(enum_member);
440 return true; // Keep iterating
444 return sb_enum_member_list;
448 SBType::GetFieldAtIndex (uint32_t idx)
450 SBTypeMember sb_type_member;
453 CompilerType this_type (m_opaque_sp->GetCompilerType (false));
454 if (this_type.IsValid())
456 uint64_t bit_offset = 0;
457 uint32_t bitfield_bit_size = 0;
458 bool is_bitfield = false;
459 std::string name_sstr;
460 CompilerType field_type (this_type.GetFieldAtIndex (idx,
465 if (field_type.IsValid())
468 if (!name_sstr.empty())
469 name.SetCString(name_sstr.c_str());
470 sb_type_member.reset (new TypeMemberImpl (TypeImplSP (new TypeImpl(field_type)),
478 return sb_type_member;
482 SBType::IsTypeComplete()
486 return m_opaque_sp->GetCompilerType(false).IsCompleteType();
490 SBType::GetTypeFlags ()
494 return m_opaque_sp->GetCompilerType(true).GetTypeInfo();
502 return m_opaque_sp->GetName().GetCString();
506 SBType::GetDisplayTypeName ()
510 return m_opaque_sp->GetDisplayTypeName().GetCString();
514 SBType::GetTypeClass ()
517 return m_opaque_sp->GetCompilerType(true).GetTypeClass();
518 return lldb::eTypeClassInvalid;
522 SBType::GetNumberOfTemplateArguments ()
525 return m_opaque_sp->GetCompilerType(false).GetNumTemplateArguments();
530 SBType::GetTemplateArgumentType (uint32_t idx)
534 TemplateArgumentKind kind = eTemplateArgumentKindNull;
535 CompilerType template_arg_type = m_opaque_sp->GetCompilerType(false).GetTemplateArgument(idx, kind);
536 if (template_arg_type.IsValid())
537 return SBType(template_arg_type);
543 lldb::TemplateArgumentKind
544 SBType::GetTemplateArgumentKind (uint32_t idx)
546 TemplateArgumentKind kind = eTemplateArgumentKindNull;
548 m_opaque_sp->GetCompilerType(false).GetTemplateArgument(idx, kind);
553 SBTypeList::SBTypeList() :
554 m_opaque_ap(new TypeListImpl())
558 SBTypeList::SBTypeList(const SBTypeList& rhs) :
559 m_opaque_ap(new TypeListImpl())
561 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList&>(rhs).GetSize(); i < rhs_size; i++)
562 Append(const_cast<SBTypeList&>(rhs).GetTypeAtIndex(i));
566 SBTypeList::IsValid ()
568 return (m_opaque_ap.get() != NULL);
572 SBTypeList::operator = (const SBTypeList& rhs)
576 m_opaque_ap.reset (new TypeListImpl());
577 for (uint32_t i = 0, rhs_size = const_cast<SBTypeList&>(rhs).GetSize(); i < rhs_size; i++)
578 Append(const_cast<SBTypeList&>(rhs).GetTypeAtIndex(i));
584 SBTypeList::Append (SBType type)
587 m_opaque_ap->Append (type.m_opaque_sp);
591 SBTypeList::GetTypeAtIndex(uint32_t index)
593 if (m_opaque_ap.get())
594 return SBType(m_opaque_ap->GetTypeAtIndex(index));
599 SBTypeList::GetSize()
601 return m_opaque_ap->GetSize();
604 SBTypeList::~SBTypeList()
608 SBTypeMember::SBTypeMember() :
613 SBTypeMember::~SBTypeMember()
617 SBTypeMember::SBTypeMember (const SBTypeMember& rhs) :
623 m_opaque_ap.reset(new TypeMemberImpl(rhs.ref()));
628 SBTypeMember::operator = (const lldb::SBTypeMember& rhs)
633 m_opaque_ap.reset(new TypeMemberImpl(rhs.ref()));
639 SBTypeMember::IsValid() const
641 return m_opaque_ap.get();
645 SBTypeMember::GetName ()
647 if (m_opaque_ap.get())
648 return m_opaque_ap->GetName().GetCString();
653 SBTypeMember::GetType ()
656 if (m_opaque_ap.get())
658 sb_type.SetSP (m_opaque_ap->GetTypeImpl());
665 SBTypeMember::GetOffsetInBytes()
667 if (m_opaque_ap.get())
668 return m_opaque_ap->GetBitOffset() / 8u;
673 SBTypeMember::GetOffsetInBits()
675 if (m_opaque_ap.get())
676 return m_opaque_ap->GetBitOffset();
681 SBTypeMember::IsBitfield()
683 if (m_opaque_ap.get())
684 return m_opaque_ap->GetIsBitfield();
689 SBTypeMember::GetBitfieldSizeInBits()
691 if (m_opaque_ap.get())
692 return m_opaque_ap->GetBitfieldBitSize();
698 SBTypeMember::GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level)
700 Stream &strm = description.ref();
702 if (m_opaque_ap.get())
704 const uint32_t bit_offset = m_opaque_ap->GetBitOffset();
705 const uint32_t byte_offset = bit_offset / 8u;
706 const uint32_t byte_bit_offset = bit_offset % 8u;
707 const char *name = m_opaque_ap->GetName().GetCString();
709 strm.Printf ("+%u + %u bits: (", byte_offset, byte_bit_offset);
711 strm.Printf ("+%u: (", byte_offset);
713 TypeImplSP type_impl_sp (m_opaque_ap->GetTypeImpl());
715 type_impl_sp->GetDescription(strm, description_level);
717 strm.Printf (") %s", name);
718 if (m_opaque_ap->GetIsBitfield())
720 const uint32_t bitfield_bit_size = m_opaque_ap->GetBitfieldBitSize();
721 strm.Printf (" : %u", bitfield_bit_size);
726 strm.PutCString ("No value");
733 SBTypeMember::reset(TypeMemberImpl *type_member_impl)
735 m_opaque_ap.reset(type_member_impl);
741 if (m_opaque_ap.get() == NULL)
742 m_opaque_ap.reset (new TypeMemberImpl());
743 return *m_opaque_ap.get();
746 const TypeMemberImpl &
747 SBTypeMember::ref () const
749 return *m_opaque_ap.get();
752 SBTypeMemberFunction::SBTypeMemberFunction() :
757 SBTypeMemberFunction::~SBTypeMemberFunction()
761 SBTypeMemberFunction::SBTypeMemberFunction (const SBTypeMemberFunction& rhs) :
762 m_opaque_sp(rhs.m_opaque_sp)
766 lldb::SBTypeMemberFunction&
767 SBTypeMemberFunction::operator = (const lldb::SBTypeMemberFunction& rhs)
770 m_opaque_sp = rhs.m_opaque_sp;
775 SBTypeMemberFunction::IsValid() const
777 return m_opaque_sp.get();
781 SBTypeMemberFunction::GetName ()
784 return m_opaque_sp->GetName().GetCString();
789 SBTypeMemberFunction::GetDemangledName ()
793 ConstString mangled_str = m_opaque_sp->GetMangledName();
796 Mangled mangled(mangled_str, true);
797 return mangled.GetDemangledName(mangled.GuessLanguage()).GetCString();
804 SBTypeMemberFunction::GetMangledName()
807 return m_opaque_sp->GetMangledName().GetCString();
813 SBTypeMemberFunction::GetType ()
818 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetType())));
824 SBTypeMemberFunction::GetReturnType ()
829 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetReturnType())));
835 SBTypeMemberFunction::GetNumberOfArguments ()
838 return m_opaque_sp->GetNumArguments();
843 SBTypeMemberFunction::GetArgumentTypeAtIndex (uint32_t i)
848 sb_type.SetSP(lldb::TypeImplSP(new TypeImpl(m_opaque_sp->GetArgumentAtIndex(i))));
853 lldb::MemberFunctionKind
854 SBTypeMemberFunction::GetKind ()
857 return m_opaque_sp->GetKind();
858 return lldb::eMemberFunctionKindUnknown;
863 SBTypeMemberFunction::GetDescription (lldb::SBStream &description,
864 lldb::DescriptionLevel description_level)
866 Stream &strm = description.ref();
869 return m_opaque_sp->GetDescription(strm);
875 SBTypeMemberFunction::reset(TypeMemberFunctionImpl *type_member_impl)
877 m_opaque_sp.reset(type_member_impl);
880 TypeMemberFunctionImpl &
881 SBTypeMemberFunction::ref ()
884 m_opaque_sp.reset (new TypeMemberFunctionImpl());
885 return *m_opaque_sp.get();
888 const TypeMemberFunctionImpl &
889 SBTypeMemberFunction::ref () const
891 return *m_opaque_sp.get();