1 //===-- ClangASTType.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/lldb-python.h"
12 #include "lldb/Symbol/ClangASTType.h"
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/CXXInheritance.h"
18 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclGroup.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/RecordLayout.h"
24 #include "clang/AST/Type.h"
26 #include "clang/Basic/Builtins.h"
27 #include "clang/Basic/IdentifierTable.h"
28 #include "clang/Basic/LangOptions.h"
29 #include "clang/Basic/SourceManager.h"
30 #include "clang/Basic/TargetInfo.h"
32 #include "llvm/Support/FormattedStream.h"
33 #include "llvm/Support/raw_ostream.h"
35 #include "lldb/Core/ConstString.h"
36 #include "lldb/Core/DataBufferHeap.h"
37 #include "lldb/Core/DataExtractor.h"
38 #include "lldb/Core/Debugger.h"
39 #include "lldb/Core/Scalar.h"
40 #include "lldb/Core/Stream.h"
41 #include "lldb/Core/StreamString.h"
42 #include "lldb/Symbol/ClangASTContext.h"
43 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
44 #include "lldb/Symbol/VerifyDecl.h"
45 #include "lldb/Target/ExecutionContext.h"
46 #include "lldb/Target/Process.h"
51 using namespace lldb_private;
52 using namespace clang;
56 GetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion = true)
58 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
61 case clang::Type::ConstantArray:
62 case clang::Type::IncompleteArray:
63 case clang::Type::VariableArray:
65 const ArrayType *array_type = dyn_cast<ArrayType>(qual_type.getTypePtr());
68 return GetCompleteQualType (ast, array_type->getElementType(), allow_completion);
72 case clang::Type::Record:
73 case clang::Type::Enum:
75 const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr());
78 TagDecl *tag_decl = tag_type->getDecl();
81 if (tag_decl->isCompleteDefinition())
84 if (!allow_completion)
87 if (tag_decl->hasExternalLexicalStorage())
91 ExternalASTSource *external_ast_source = ast->getExternalSource();
92 if (external_ast_source)
94 external_ast_source->CompleteType(tag_decl);
95 return !tag_type->isIncompleteType();
106 case clang::Type::ObjCObject:
107 case clang::Type::ObjCInterface:
109 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
112 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
113 // We currently can't complete objective C types through the newly added ASTContext
114 // because it only supports TagDecl objects right now...
115 if (class_interface_decl)
117 if (class_interface_decl->getDefinition())
120 if (!allow_completion)
123 if (class_interface_decl->hasExternalLexicalStorage())
127 ExternalASTSource *external_ast_source = ast->getExternalSource();
128 if (external_ast_source)
130 external_ast_source->CompleteType (class_interface_decl);
131 return !objc_class_type->isIncompleteType();
141 case clang::Type::Typedef:
142 return GetCompleteQualType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion);
144 case clang::Type::Elaborated:
145 return GetCompleteQualType (ast, cast<ElaboratedType>(qual_type)->getNamedType(), allow_completion);
147 case clang::Type::Paren:
148 return GetCompleteQualType (ast, cast<ParenType>(qual_type)->desugar(), allow_completion);
157 static ObjCIvarDecl::AccessControl
158 ConvertAccessTypeToObjCIvarAccessControl (AccessType access)
162 case eAccessNone: return ObjCIvarDecl::None;
163 case eAccessPublic: return ObjCIvarDecl::Public;
164 case eAccessPrivate: return ObjCIvarDecl::Private;
165 case eAccessProtected: return ObjCIvarDecl::Protected;
166 case eAccessPackage: return ObjCIvarDecl::Package;
168 return ObjCIvarDecl::None;
171 //----------------------------------------------------------------------
173 //----------------------------------------------------------------------
175 ClangASTType::ClangASTType (clang::ASTContext *ast,
176 clang::QualType qual_type) :
177 m_type (qual_type.getAsOpaquePtr()),
182 ClangASTType::~ClangASTType()
186 //----------------------------------------------------------------------
188 //----------------------------------------------------------------------
191 ClangASTType::IsAggregateType () const
196 QualType qual_type (GetCanonicalQualType());
198 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
201 case clang::Type::IncompleteArray:
202 case clang::Type::VariableArray:
203 case clang::Type::ConstantArray:
204 case clang::Type::ExtVector:
205 case clang::Type::Vector:
206 case clang::Type::Record:
207 case clang::Type::ObjCObject:
208 case clang::Type::ObjCInterface:
210 case clang::Type::Elaborated:
211 return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsAggregateType();
212 case clang::Type::Typedef:
213 return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsAggregateType();
214 case clang::Type::Paren:
215 return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).IsAggregateType();
219 // The clang type does have a value
224 ClangASTType::IsArrayType (ClangASTType *element_type_ptr,
226 bool *is_incomplete) const
230 QualType qual_type (GetCanonicalQualType());
232 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
238 case clang::Type::ConstantArray:
239 if (element_type_ptr)
240 element_type_ptr->SetClangType (m_ast, cast<ConstantArrayType>(qual_type)->getElementType());
242 *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX);
245 case clang::Type::IncompleteArray:
246 if (element_type_ptr)
247 element_type_ptr->SetClangType (m_ast, cast<IncompleteArrayType>(qual_type)->getElementType());
251 *is_incomplete = true;
254 case clang::Type::VariableArray:
255 if (element_type_ptr)
256 element_type_ptr->SetClangType (m_ast, cast<VariableArrayType>(qual_type)->getElementType());
261 case clang::Type::DependentSizedArray:
262 if (element_type_ptr)
263 element_type_ptr->SetClangType (m_ast, cast<DependentSizedArrayType>(qual_type)->getElementType());
268 case clang::Type::Typedef:
269 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsArrayType (element_type_ptr,
272 case clang::Type::Elaborated:
273 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsArrayType (element_type_ptr,
276 case clang::Type::Paren:
277 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsArrayType (element_type_ptr,
282 if (element_type_ptr)
283 element_type_ptr->Clear();
287 *is_incomplete = false;
293 ClangASTType::IsCharType () const
297 return GetQualType().getUnqualifiedType()->isCharType();
302 ClangASTType::IsCompleteType () const
306 const bool allow_completion = false;
307 return GetCompleteQualType (m_ast, GetQualType(), allow_completion);
311 ClangASTType::IsConst() const
313 return GetQualType().isConstQualified();
317 ClangASTType::IsCStringType (uint32_t &length) const
319 ClangASTType pointee_or_element_clang_type;
321 Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type));
323 if (!pointee_or_element_clang_type.IsValid())
326 if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer))
328 if (pointee_or_element_clang_type.IsCharType())
330 if (type_flags.Test (eTypeIsArray))
332 // We know the size of the array and it could be a C string
333 // since it is an array of characters
334 length = cast<ConstantArrayType>(GetCanonicalQualType().getTypePtr())->getSize().getLimitedValue();
344 ClangASTType::IsFunctionType (bool *is_variadic_ptr) const
348 QualType qual_type (GetCanonicalQualType());
350 if (qual_type->isFunctionType())
354 const clang::FunctionProtoType *function_proto_type = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr());
355 if (function_proto_type)
356 *is_variadic_ptr = function_proto_type->isVariadic();
358 *is_variadic_ptr = false;
363 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
368 case clang::Type::Typedef:
369 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionType();
370 case clang::Type::Elaborated:
371 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsFunctionType();
372 case clang::Type::Paren:
373 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsFunctionType();
375 case clang::Type::LValueReference:
376 case clang::Type::RValueReference:
378 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
380 return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionType();
390 ClangASTType::IsFunctionPointerType () const
394 QualType qual_type (GetCanonicalQualType());
396 if (qual_type->isFunctionPointerType())
399 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
404 case clang::Type::Typedef:
405 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionPointerType();
406 case clang::Type::Elaborated:
407 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsFunctionPointerType();
408 case clang::Type::Paren:
409 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsFunctionPointerType();
411 case clang::Type::LValueReference:
412 case clang::Type::RValueReference:
414 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
416 return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionPointerType();
426 ClangASTType::IsIntegerType (bool &is_signed) const
431 QualType qual_type (GetCanonicalQualType());
432 const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal());
436 if (builtin_type->isInteger())
438 is_signed = builtin_type->isSignedInteger();
447 ClangASTType::IsPointerType (ClangASTType *pointee_type) const
451 QualType qual_type (GetCanonicalQualType());
452 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
455 case clang::Type::Builtin:
456 switch (cast<clang::BuiltinType>(qual_type)->getKind())
460 case clang::BuiltinType::ObjCId:
461 case clang::BuiltinType::ObjCClass:
465 case clang::Type::ObjCObjectPointer:
467 pointee_type->SetClangType (m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType());
469 case clang::Type::BlockPointer:
471 pointee_type->SetClangType (m_ast, cast<BlockPointerType>(qual_type)->getPointeeType());
473 case clang::Type::Pointer:
475 pointee_type->SetClangType (m_ast, cast<PointerType>(qual_type)->getPointeeType());
477 case clang::Type::MemberPointer:
479 pointee_type->SetClangType (m_ast, cast<MemberPointerType>(qual_type)->getPointeeType());
481 case clang::Type::Typedef:
482 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerType(pointee_type);
483 case clang::Type::Elaborated:
484 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsPointerType(pointee_type);
485 case clang::Type::Paren:
486 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsPointerType(pointee_type);
492 pointee_type->Clear();
498 ClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const
502 QualType qual_type (GetCanonicalQualType());
503 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
506 case clang::Type::Builtin:
507 switch (cast<clang::BuiltinType>(qual_type)->getKind())
511 case clang::BuiltinType::ObjCId:
512 case clang::BuiltinType::ObjCClass:
516 case clang::Type::ObjCObjectPointer:
518 pointee_type->SetClangType(m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType());
520 case clang::Type::BlockPointer:
522 pointee_type->SetClangType(m_ast, cast<BlockPointerType>(qual_type)->getPointeeType());
524 case clang::Type::Pointer:
526 pointee_type->SetClangType(m_ast, cast<PointerType>(qual_type)->getPointeeType());
528 case clang::Type::MemberPointer:
530 pointee_type->SetClangType(m_ast, cast<MemberPointerType>(qual_type)->getPointeeType());
532 case clang::Type::LValueReference:
534 pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar());
536 case clang::Type::RValueReference:
538 pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar());
540 case clang::Type::Typedef:
541 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerOrReferenceType(pointee_type);
542 case clang::Type::Elaborated:
543 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsPointerOrReferenceType(pointee_type);
544 case clang::Type::Paren:
545 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsPointerOrReferenceType(pointee_type);
551 pointee_type->Clear();
557 ClangASTType::IsReferenceType (ClangASTType *pointee_type) const
561 QualType qual_type (GetCanonicalQualType());
562 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
566 case clang::Type::LValueReference:
568 pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar());
570 case clang::Type::RValueReference:
572 pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar());
574 case clang::Type::Typedef:
575 return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsReferenceType(pointee_type);
576 case clang::Type::Elaborated:
577 return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsReferenceType(pointee_type);
578 case clang::Type::Paren:
579 return ClangASTType(m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsReferenceType(pointee_type);
586 pointee_type->Clear();
591 ClangASTType::IsFloatingPointType (uint32_t &count, bool &is_complex) const
595 QualType qual_type (GetCanonicalQualType());
597 if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()))
599 clang::BuiltinType::Kind kind = BT->getKind();
600 if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble)
607 else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal()))
609 if (ClangASTType (m_ast, CT->getElementType()).IsFloatingPointType (count, is_complex))
616 else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal()))
618 if (ClangASTType (m_ast, VT->getElementType()).IsFloatingPointType (count, is_complex))
620 count = VT->getNumElements();
633 ClangASTType::IsDefined() const
638 QualType qual_type(GetQualType());
639 const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr());
642 TagDecl *tag_decl = tag_type->getDecl();
644 return tag_decl->isCompleteDefinition();
649 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
652 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
653 if (class_interface_decl)
654 return class_interface_decl->getDefinition() != NULL;
662 ClangASTType::IsObjCClassType () const
666 QualType qual_type (GetCanonicalQualType());
668 const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type);
670 if (obj_pointer_type)
671 return obj_pointer_type->isObjCClassType();
677 ClangASTType::IsObjCObjectOrInterfaceType () const
680 return GetCanonicalQualType()->isObjCObjectOrInterfaceType();
685 ClangASTType::IsPolymorphicClass () const
689 QualType qual_type(GetCanonicalQualType());
690 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
693 case clang::Type::Record:
694 if (GetCompleteType())
696 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
697 const RecordDecl *record_decl = record_type->getDecl();
700 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
702 return cxx_record_decl->isPolymorphic();
715 ClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type,
716 bool check_cplusplus,
717 bool check_objc) const
719 QualType pointee_qual_type;
722 QualType qual_type (GetCanonicalQualType());
723 bool success = false;
724 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
727 case clang::Type::Builtin:
728 if (check_objc && cast<BuiltinType>(qual_type)->getKind() == BuiltinType::ObjCId)
730 if (dynamic_pointee_type)
731 dynamic_pointee_type->SetClangType(m_ast, m_type);
736 case clang::Type::ObjCObjectPointer:
739 if (dynamic_pointee_type)
740 dynamic_pointee_type->SetClangType(m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType());
745 case clang::Type::Pointer:
746 pointee_qual_type = cast<PointerType>(qual_type)->getPointeeType();
750 case clang::Type::LValueReference:
751 case clang::Type::RValueReference:
752 pointee_qual_type = cast<ReferenceType>(qual_type)->getPointeeType();
756 case clang::Type::Typedef:
757 return ClangASTType (m_ast,
758 cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPossibleDynamicType (dynamic_pointee_type,
762 case clang::Type::Elaborated:
763 return ClangASTType (m_ast,
764 cast<ElaboratedType>(qual_type)->getNamedType()).IsPossibleDynamicType (dynamic_pointee_type,
768 case clang::Type::Paren:
769 return ClangASTType (m_ast,
770 cast<ParenType>(qual_type)->desugar()).IsPossibleDynamicType (dynamic_pointee_type,
779 // Check to make sure what we are pointing too is a possible dynamic C++ type
780 // We currently accept any "void *" (in case we have a class that has been
781 // watered down to an opaque pointer) and virtual C++ classes.
782 const clang::Type::TypeClass pointee_type_class = pointee_qual_type.getCanonicalType()->getTypeClass();
783 switch (pointee_type_class)
785 case clang::Type::Builtin:
786 switch (cast<BuiltinType>(pointee_qual_type)->getKind())
788 case BuiltinType::UnknownAny:
789 case BuiltinType::Void:
790 if (dynamic_pointee_type)
791 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type);
794 case BuiltinType::NullPtr:
795 case BuiltinType::Bool:
796 case BuiltinType::Char_U:
797 case BuiltinType::UChar:
798 case BuiltinType::WChar_U:
799 case BuiltinType::Char16:
800 case BuiltinType::Char32:
801 case BuiltinType::UShort:
802 case BuiltinType::UInt:
803 case BuiltinType::ULong:
804 case BuiltinType::ULongLong:
805 case BuiltinType::UInt128:
806 case BuiltinType::Char_S:
807 case BuiltinType::SChar:
808 case BuiltinType::WChar_S:
809 case BuiltinType::Short:
810 case BuiltinType::Int:
811 case BuiltinType::Long:
812 case BuiltinType::LongLong:
813 case BuiltinType::Int128:
814 case BuiltinType::Float:
815 case BuiltinType::Double:
816 case BuiltinType::LongDouble:
817 case BuiltinType::Dependent:
818 case BuiltinType::Overload:
819 case BuiltinType::ObjCId:
820 case BuiltinType::ObjCClass:
821 case BuiltinType::ObjCSel:
822 case BuiltinType::BoundMember:
823 case BuiltinType::Half:
824 case BuiltinType::ARCUnbridgedCast:
825 case BuiltinType::PseudoObject:
826 case BuiltinType::BuiltinFn:
827 case BuiltinType::OCLEvent:
828 case BuiltinType::OCLImage1d:
829 case BuiltinType::OCLImage1dArray:
830 case BuiltinType::OCLImage1dBuffer:
831 case BuiltinType::OCLImage2d:
832 case BuiltinType::OCLImage2dArray:
833 case BuiltinType::OCLImage3d:
834 case BuiltinType::OCLSampler:
839 case clang::Type::Record:
842 CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl();
845 bool is_complete = cxx_record_decl->isCompleteDefinition();
848 success = cxx_record_decl->isDynamicClass();
851 ClangASTMetadata *metadata = ClangASTContext::GetMetadata (m_ast, cxx_record_decl);
853 success = metadata->GetIsDynamicCXXType();
856 is_complete = ClangASTType(m_ast, pointee_qual_type).GetCompleteType();
858 success = cxx_record_decl->isDynamicClass();
866 if (dynamic_pointee_type)
867 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type);
874 case clang::Type::ObjCObject:
875 case clang::Type::ObjCInterface:
878 if (dynamic_pointee_type)
879 dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type);
889 if (dynamic_pointee_type)
890 dynamic_pointee_type->Clear();
896 ClangASTType::IsScalarType () const
901 return (GetTypeInfo (NULL) & eTypeIsScalar) != 0;
905 ClangASTType::IsTypedefType () const
909 return GetQualType()->getTypeClass() == clang::Type::Typedef;
913 ClangASTType::IsVoidType () const
917 return GetCanonicalQualType()->isVoidType();
921 ClangASTType::IsPointerToScalarType () const
926 return IsPointerType() && GetPointeeType().IsScalarType();
930 ClangASTType::IsArrayOfScalarType () const
932 ClangASTType element_type;
933 if (IsArrayType(&element_type, NULL, NULL))
934 return element_type.IsScalarType();
940 ClangASTType::GetCXXClassName (std::string &class_name) const
944 QualType qual_type (GetCanonicalQualType());
946 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
949 class_name.assign (cxx_record_decl->getIdentifier()->getNameStart());
959 ClangASTType::IsCXXClassType () const
964 QualType qual_type (GetCanonicalQualType());
965 if (qual_type->getAsCXXRecordDecl() != NULL)
971 ClangASTType::IsBeingDefined () const
975 QualType qual_type (GetCanonicalQualType());
976 const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type);
978 return tag_type->isBeingDefined();
983 ClangASTType::IsObjCObjectPointerType (ClangASTType *class_type_ptr)
988 QualType qual_type (GetCanonicalQualType());
990 if (qual_type->isObjCObjectPointerType())
994 if (!qual_type->isObjCClassType() &&
995 !qual_type->isObjCIdType())
997 const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type);
998 if (obj_pointer_type == NULL)
999 class_type_ptr->Clear();
1001 class_type_ptr->SetClangType (m_ast, QualType(obj_pointer_type->getInterfaceType(), 0));
1007 class_type_ptr->Clear();
1012 ClangASTType::GetObjCClassName (std::string &class_name)
1017 QualType qual_type (GetCanonicalQualType());
1019 const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(qual_type);
1022 const ObjCInterfaceDecl *interface = object_type->getInterface();
1025 class_name = interface->getNameAsString();
1033 //----------------------------------------------------------------------
1035 //----------------------------------------------------------------------
1038 ClangASTType::GetCompleteType () const
1042 const bool allow_completion = true;
1043 return GetCompleteQualType (m_ast, GetQualType(), allow_completion);
1046 //----------------------------------------------------------------------
1047 // AST related queries
1048 //----------------------------------------------------------------------
1050 ClangASTType::GetPointerByteSize () const
1053 return m_ast->getTypeSize(m_ast->VoidPtrTy) / 8;
1058 ClangASTType::GetConstQualifiedTypeName () const
1060 return GetConstTypeName ();
1064 ClangASTType::GetConstTypeName () const
1068 std::string type_name (GetTypeName());
1069 if (!type_name.empty())
1070 return ConstString (type_name.c_str());
1072 return ConstString("<invalid>");
1076 ClangASTType::GetTypeName () const
1078 std::string type_name;
1081 PrintingPolicy printing_policy (m_ast->getPrintingPolicy());
1082 QualType qual_type(GetQualType());
1083 printing_policy.SuppressTagKeyword = true;
1084 printing_policy.LangOpts.WChar = true;
1085 const TypedefType *typedef_type = qual_type->getAs<TypedefType>();
1088 const TypedefNameDecl *typedef_decl = typedef_type->getDecl();
1089 type_name = typedef_decl->getQualifiedNameAsString(printing_policy);
1093 type_name = qual_type.getAsString(printing_policy);
1101 ClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const
1106 if (pointee_or_element_clang_type)
1107 pointee_or_element_clang_type->Clear();
1109 QualType qual_type (GetQualType());
1111 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1114 case clang::Type::Builtin:
1116 const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal());
1118 uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue;
1119 switch (builtin_type->getKind())
1121 case clang::BuiltinType::ObjCId:
1122 case clang::BuiltinType::ObjCClass:
1123 if (pointee_or_element_clang_type)
1124 pointee_or_element_clang_type->SetClangType(m_ast, m_ast->ObjCBuiltinClassTy);
1125 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
1128 case clang::BuiltinType::ObjCSel:
1129 if (pointee_or_element_clang_type)
1130 pointee_or_element_clang_type->SetClangType(m_ast, m_ast->CharTy);
1131 builtin_type_flags |= eTypeIsPointer | eTypeIsObjC;
1134 case clang::BuiltinType::Bool:
1135 case clang::BuiltinType::Char_U:
1136 case clang::BuiltinType::UChar:
1137 case clang::BuiltinType::WChar_U:
1138 case clang::BuiltinType::Char16:
1139 case clang::BuiltinType::Char32:
1140 case clang::BuiltinType::UShort:
1141 case clang::BuiltinType::UInt:
1142 case clang::BuiltinType::ULong:
1143 case clang::BuiltinType::ULongLong:
1144 case clang::BuiltinType::UInt128:
1145 case clang::BuiltinType::Char_S:
1146 case clang::BuiltinType::SChar:
1147 case clang::BuiltinType::WChar_S:
1148 case clang::BuiltinType::Short:
1149 case clang::BuiltinType::Int:
1150 case clang::BuiltinType::Long:
1151 case clang::BuiltinType::LongLong:
1152 case clang::BuiltinType::Int128:
1153 case clang::BuiltinType::Float:
1154 case clang::BuiltinType::Double:
1155 case clang::BuiltinType::LongDouble:
1156 builtin_type_flags |= eTypeIsScalar;
1157 if (builtin_type->isInteger())
1159 builtin_type_flags |= eTypeIsInteger;
1160 if (builtin_type->isSignedInteger())
1161 builtin_type_flags |= eTypeIsSigned;
1163 else if (builtin_type->isFloatingPoint())
1164 builtin_type_flags |= eTypeIsFloat;
1169 return builtin_type_flags;
1172 case clang::Type::BlockPointer:
1173 if (pointee_or_element_clang_type)
1174 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType());
1175 return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
1177 case clang::Type::Complex:
1179 uint32_t complex_type_flags = eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex;
1180 const ComplexType *complex_type = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal());
1183 QualType complex_element_type (complex_type->getElementType());
1184 if (complex_element_type->isIntegerType())
1185 complex_type_flags |= eTypeIsFloat;
1186 else if (complex_element_type->isFloatingType())
1187 complex_type_flags |= eTypeIsInteger;
1189 return complex_type_flags;
1193 case clang::Type::ConstantArray:
1194 case clang::Type::DependentSizedArray:
1195 case clang::Type::IncompleteArray:
1196 case clang::Type::VariableArray:
1197 if (pointee_or_element_clang_type)
1198 pointee_or_element_clang_type->SetClangType(m_ast, cast<ArrayType>(qual_type.getTypePtr())->getElementType());
1199 return eTypeHasChildren | eTypeIsArray;
1201 case clang::Type::DependentName: return 0;
1202 case clang::Type::DependentSizedExtVector: return eTypeHasChildren | eTypeIsVector;
1203 case clang::Type::DependentTemplateSpecialization: return eTypeIsTemplate;
1204 case clang::Type::Decltype: return 0;
1206 case clang::Type::Enum:
1207 if (pointee_or_element_clang_type)
1208 pointee_or_element_clang_type->SetClangType(m_ast, cast<EnumType>(qual_type)->getDecl()->getIntegerType());
1209 return eTypeIsEnumeration | eTypeHasValue;
1211 case clang::Type::Elaborated:
1212 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type);
1213 case clang::Type::Paren:
1214 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type);
1216 case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue;
1217 case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue;
1218 case clang::Type::InjectedClassName: return 0;
1220 case clang::Type::LValueReference:
1221 case clang::Type::RValueReference:
1222 if (pointee_or_element_clang_type)
1223 pointee_or_element_clang_type->SetClangType(m_ast, cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType());
1224 return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
1226 case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue;
1228 case clang::Type::ObjCObjectPointer:
1229 if (pointee_or_element_clang_type)
1230 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType());
1231 return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue;
1233 case clang::Type::ObjCObject: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
1234 case clang::Type::ObjCInterface: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
1236 case clang::Type::Pointer:
1237 if (pointee_or_element_clang_type)
1238 pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType());
1239 return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
1241 case clang::Type::Record:
1242 if (qual_type->getAsCXXRecordDecl())
1243 return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
1245 return eTypeHasChildren | eTypeIsStructUnion;
1247 case clang::Type::SubstTemplateTypeParm: return eTypeIsTemplate;
1248 case clang::Type::TemplateTypeParm: return eTypeIsTemplate;
1249 case clang::Type::TemplateSpecialization: return eTypeIsTemplate;
1251 case clang::Type::Typedef:
1252 return eTypeIsTypedef | ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type);
1253 case clang::Type::TypeOfExpr: return 0;
1254 case clang::Type::TypeOf: return 0;
1255 case clang::Type::UnresolvedUsing: return 0;
1257 case clang::Type::ExtVector:
1258 case clang::Type::Vector:
1260 uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector;
1261 const VectorType *vector_type = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal());
1264 if (vector_type->isIntegerType())
1265 vector_type_flags |= eTypeIsFloat;
1266 else if (vector_type->isFloatingType())
1267 vector_type_flags |= eTypeIsInteger;
1269 return vector_type_flags;
1279 ClangASTType::GetMinimumLanguage ()
1282 return lldb::eLanguageTypeC;
1284 // If the type is a reference, then resolve it to what it refers to first:
1285 QualType qual_type (GetCanonicalQualType().getNonReferenceType());
1286 if (qual_type->isAnyPointerType())
1288 if (qual_type->isObjCObjectPointerType())
1289 return lldb::eLanguageTypeObjC;
1291 QualType pointee_type (qual_type->getPointeeType());
1292 if (pointee_type->getPointeeCXXRecordDecl() != NULL)
1293 return lldb::eLanguageTypeC_plus_plus;
1294 if (pointee_type->isObjCObjectOrInterfaceType())
1295 return lldb::eLanguageTypeObjC;
1296 if (pointee_type->isObjCClassType())
1297 return lldb::eLanguageTypeObjC;
1298 if (pointee_type.getTypePtr() == m_ast->ObjCBuiltinIdTy.getTypePtr())
1299 return lldb::eLanguageTypeObjC;
1303 if (qual_type->isObjCObjectOrInterfaceType())
1304 return lldb::eLanguageTypeObjC;
1305 if (qual_type->getAsCXXRecordDecl())
1306 return lldb::eLanguageTypeC_plus_plus;
1307 switch (qual_type->getTypeClass())
1311 case clang::Type::Builtin:
1312 switch (cast<BuiltinType>(qual_type)->getKind())
1315 case BuiltinType::Void:
1316 case BuiltinType::Bool:
1317 case BuiltinType::Char_U:
1318 case BuiltinType::UChar:
1319 case BuiltinType::WChar_U:
1320 case BuiltinType::Char16:
1321 case BuiltinType::Char32:
1322 case BuiltinType::UShort:
1323 case BuiltinType::UInt:
1324 case BuiltinType::ULong:
1325 case BuiltinType::ULongLong:
1326 case BuiltinType::UInt128:
1327 case BuiltinType::Char_S:
1328 case BuiltinType::SChar:
1329 case BuiltinType::WChar_S:
1330 case BuiltinType::Short:
1331 case BuiltinType::Int:
1332 case BuiltinType::Long:
1333 case BuiltinType::LongLong:
1334 case BuiltinType::Int128:
1335 case BuiltinType::Float:
1336 case BuiltinType::Double:
1337 case BuiltinType::LongDouble:
1340 case BuiltinType::NullPtr:
1341 return eLanguageTypeC_plus_plus;
1343 case BuiltinType::ObjCId:
1344 case BuiltinType::ObjCClass:
1345 case BuiltinType::ObjCSel:
1346 return eLanguageTypeObjC;
1348 case BuiltinType::Dependent:
1349 case BuiltinType::Overload:
1350 case BuiltinType::BoundMember:
1351 case BuiltinType::UnknownAny:
1355 case clang::Type::Typedef:
1356 return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage();
1359 return lldb::eLanguageTypeC;
1363 ClangASTType::GetTypeClass () const
1366 return lldb::eTypeClassInvalid;
1368 QualType qual_type(GetQualType());
1370 switch (qual_type->getTypeClass())
1372 case clang::Type::UnaryTransform: break;
1373 case clang::Type::FunctionNoProto: return lldb::eTypeClassFunction;
1374 case clang::Type::FunctionProto: return lldb::eTypeClassFunction;
1375 case clang::Type::IncompleteArray: return lldb::eTypeClassArray;
1376 case clang::Type::VariableArray: return lldb::eTypeClassArray;
1377 case clang::Type::ConstantArray: return lldb::eTypeClassArray;
1378 case clang::Type::DependentSizedArray: return lldb::eTypeClassArray;
1379 case clang::Type::DependentSizedExtVector: return lldb::eTypeClassVector;
1380 case clang::Type::ExtVector: return lldb::eTypeClassVector;
1381 case clang::Type::Vector: return lldb::eTypeClassVector;
1382 case clang::Type::Builtin: return lldb::eTypeClassBuiltin;
1383 case clang::Type::ObjCObjectPointer: return lldb::eTypeClassObjCObjectPointer;
1384 case clang::Type::BlockPointer: return lldb::eTypeClassBlockPointer;
1385 case clang::Type::Pointer: return lldb::eTypeClassPointer;
1386 case clang::Type::LValueReference: return lldb::eTypeClassReference;
1387 case clang::Type::RValueReference: return lldb::eTypeClassReference;
1388 case clang::Type::MemberPointer: return lldb::eTypeClassMemberPointer;
1389 case clang::Type::Complex:
1390 if (qual_type->isComplexType())
1391 return lldb::eTypeClassComplexFloat;
1393 return lldb::eTypeClassComplexInteger;
1394 case clang::Type::ObjCObject: return lldb::eTypeClassObjCObject;
1395 case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface;
1396 case clang::Type::Record:
1398 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
1399 const RecordDecl *record_decl = record_type->getDecl();
1400 if (record_decl->isUnion())
1401 return lldb::eTypeClassUnion;
1402 else if (record_decl->isStruct())
1403 return lldb::eTypeClassStruct;
1405 return lldb::eTypeClassClass;
1408 case clang::Type::Enum: return lldb::eTypeClassEnumeration;
1409 case clang::Type::Typedef: return lldb::eTypeClassTypedef;
1410 case clang::Type::UnresolvedUsing: break;
1411 case clang::Type::Paren:
1412 return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).GetTypeClass();
1413 case clang::Type::Elaborated:
1414 return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTypeClass();
1416 case clang::Type::Attributed: break;
1417 case clang::Type::TemplateTypeParm: break;
1418 case clang::Type::SubstTemplateTypeParm: break;
1419 case clang::Type::SubstTemplateTypeParmPack:break;
1420 case clang::Type::Auto: break;
1421 case clang::Type::InjectedClassName: break;
1422 case clang::Type::DependentName: break;
1423 case clang::Type::DependentTemplateSpecialization: break;
1424 case clang::Type::PackExpansion: break;
1426 case clang::Type::TypeOfExpr: break;
1427 case clang::Type::TypeOf: break;
1428 case clang::Type::Decltype: break;
1429 case clang::Type::TemplateSpecialization: break;
1430 case clang::Type::Atomic: break;
1432 // We don't know hot to display this type...
1433 return lldb::eTypeClassOther;
1438 ClangASTType::SetClangType (clang::ASTContext *ast, clang::QualType qual_type)
1441 m_type = qual_type.getAsOpaquePtr();
1445 ClangASTType::GetTypeQualifiers() const
1448 return GetQualType().getQualifiers().getCVRQualifiers();
1452 //----------------------------------------------------------------------
1453 // Creating related types
1454 //----------------------------------------------------------------------
1457 ClangASTType::AddConstModifier () const
1461 QualType result(GetQualType());
1463 return ClangASTType (m_ast, result);
1465 return ClangASTType();
1469 ClangASTType::AddRestrictModifier () const
1473 QualType result(GetQualType());
1474 result.getQualifiers().setRestrict (true);
1475 return ClangASTType (m_ast, result);
1477 return ClangASTType();
1481 ClangASTType::AddVolatileModifier () const
1485 QualType result(GetQualType());
1486 result.getQualifiers().setVolatile (true);
1487 return ClangASTType (m_ast, result);
1489 return ClangASTType();
1493 ClangASTType::GetArrayElementType (uint64_t& stride) const
1497 QualType qual_type(GetCanonicalQualType());
1499 ClangASTType element_type (m_ast, qual_type.getTypePtr()->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified());
1501 // TODO: the real stride will be >= this value.. find the real one!
1502 stride = element_type.GetByteSize();
1504 return element_type;
1507 return ClangASTType();
1511 ClangASTType::GetCanonicalType () const
1514 return ClangASTType (m_ast, GetCanonicalQualType());
1515 return ClangASTType();
1519 GetFullyUnqualifiedType_Impl (ASTContext *ast, QualType qual_type)
1521 if (qual_type->isPointerType())
1522 qual_type = ast->getPointerType(GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType()));
1524 qual_type = qual_type.getUnqualifiedType();
1525 qual_type.removeLocalConst();
1526 qual_type.removeLocalRestrict();
1527 qual_type.removeLocalVolatile();
1532 ClangASTType::GetFullyUnqualifiedType () const
1535 return ClangASTType(m_ast, GetFullyUnqualifiedType_Impl(m_ast, GetQualType()));
1536 return ClangASTType();
1541 ClangASTType::GetFunctionArgumentCount () const
1545 const FunctionProtoType* func = dyn_cast<FunctionProtoType>(GetCanonicalQualType());
1547 return func->getNumArgs();
1553 ClangASTType::GetFunctionArgumentTypeAtIndex (size_t idx)
1557 const FunctionProtoType* func = dyn_cast<FunctionProtoType>(GetCanonicalQualType());
1560 const uint32_t num_args = func->getNumArgs();
1562 return ClangASTType(m_ast, func->getArgType(idx));
1565 return ClangASTType();
1569 ClangASTType::GetFunctionReturnType () const
1573 QualType qual_type(GetCanonicalQualType());
1574 const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr());
1576 return ClangASTType(m_ast, func->getResultType());
1578 return ClangASTType();
1583 ClangASTType::GetLValueReferenceType () const
1587 return ClangASTType(m_ast, m_ast->getLValueReferenceType(GetQualType()));
1589 return ClangASTType();
1593 ClangASTType::GetRValueReferenceType () const
1597 return ClangASTType(m_ast, m_ast->getRValueReferenceType(GetQualType()));
1599 return ClangASTType();
1603 ClangASTType::GetNonReferenceType () const
1606 return ClangASTType(m_ast, GetQualType().getNonReferenceType());
1607 return ClangASTType();
1611 ClangASTType::CreateTypedefType (const char *typedef_name,
1612 clang::DeclContext *decl_ctx) const
1614 if (IsValid() && typedef_name && typedef_name[0])
1616 QualType qual_type (GetQualType());
1617 if (decl_ctx == NULL)
1618 decl_ctx = m_ast->getTranslationUnitDecl();
1619 TypedefDecl *decl = TypedefDecl::Create (*m_ast,
1623 &m_ast->Idents.get(typedef_name),
1624 m_ast->getTrivialTypeSourceInfo(qual_type));
1626 decl->setAccess(AS_public); // TODO respect proper access specifier
1628 // Get a uniqued QualType for the typedef decl type
1629 return ClangASTType (m_ast, m_ast->getTypedefType (decl));
1631 return ClangASTType();
1636 ClangASTType::GetPointeeType () const
1640 QualType qual_type(GetQualType());
1641 return ClangASTType (m_ast, qual_type.getTypePtr()->getPointeeType());
1643 return ClangASTType();
1647 ClangASTType::GetPointerType () const
1651 QualType qual_type (GetQualType());
1653 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1656 case clang::Type::ObjCObject:
1657 case clang::Type::ObjCInterface:
1658 return ClangASTType(m_ast, m_ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr());
1661 return ClangASTType(m_ast, m_ast->getPointerType(qual_type).getAsOpaquePtr());
1664 return ClangASTType();
1668 ClangASTType::GetTypedefedType () const
1672 const TypedefType *typedef_type = dyn_cast<TypedefType>(GetQualType());
1674 return ClangASTType (m_ast, typedef_type->getDecl()->getUnderlyingType());
1676 return ClangASTType();
1680 ClangASTType::RemoveFastQualifiers () const
1684 QualType qual_type(GetQualType());
1685 qual_type.getQualifiers().removeFastQualifiers();
1686 return ClangASTType (m_ast, qual_type);
1688 return ClangASTType();
1692 //----------------------------------------------------------------------
1693 // Create related types using the current type's AST
1694 //----------------------------------------------------------------------
1697 ClangASTType::GetBasicTypeFromAST (lldb::BasicType basic_type) const
1700 return ClangASTContext::GetBasicType(m_ast, basic_type);
1701 return ClangASTType();
1703 //----------------------------------------------------------------------
1704 // Exploring the type
1705 //----------------------------------------------------------------------
1708 ClangASTType::GetBitSize () const
1710 if (GetCompleteType ())
1712 QualType qual_type(GetCanonicalQualType());
1713 const uint32_t bit_size = m_ast->getTypeSize (qual_type);
1716 if (qual_type->isIncompleteArrayType())
1717 return m_ast->getTypeSize (qual_type->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified());
1719 if (qual_type->isObjCObjectOrInterfaceType())
1720 return bit_size + m_ast->getTypeSize(m_ast->ObjCBuiltinClassTy);
1727 ClangASTType::GetByteSize () const
1729 return (GetBitSize () + 7) / 8;
1733 ClangASTType::GetTypeBitAlign () const
1735 if (GetCompleteType ())
1736 return m_ast->getTypeAlign(GetQualType());
1742 ClangASTType::GetEncoding (uint64_t &count) const
1745 return lldb::eEncodingInvalid;
1748 QualType qual_type(GetCanonicalQualType());
1750 switch (qual_type->getTypeClass())
1752 case clang::Type::UnaryTransform:
1755 case clang::Type::FunctionNoProto:
1756 case clang::Type::FunctionProto:
1759 case clang::Type::IncompleteArray:
1760 case clang::Type::VariableArray:
1763 case clang::Type::ConstantArray:
1766 case clang::Type::ExtVector:
1767 case clang::Type::Vector:
1768 // TODO: Set this to more than one???
1771 case clang::Type::Builtin:
1772 switch (cast<BuiltinType>(qual_type)->getKind())
1774 default: assert(0 && "Unknown builtin type!");
1775 case BuiltinType::Void:
1778 case BuiltinType::Bool:
1779 case BuiltinType::Char_S:
1780 case BuiltinType::SChar:
1781 case BuiltinType::WChar_S:
1782 case BuiltinType::Char16:
1783 case BuiltinType::Char32:
1784 case BuiltinType::Short:
1785 case BuiltinType::Int:
1786 case BuiltinType::Long:
1787 case BuiltinType::LongLong:
1788 case BuiltinType::Int128: return lldb::eEncodingSint;
1790 case BuiltinType::Char_U:
1791 case BuiltinType::UChar:
1792 case BuiltinType::WChar_U:
1793 case BuiltinType::UShort:
1794 case BuiltinType::UInt:
1795 case BuiltinType::ULong:
1796 case BuiltinType::ULongLong:
1797 case BuiltinType::UInt128: return lldb::eEncodingUint;
1799 case BuiltinType::Float:
1800 case BuiltinType::Double:
1801 case BuiltinType::LongDouble: return lldb::eEncodingIEEE754;
1803 case BuiltinType::ObjCClass:
1804 case BuiltinType::ObjCId:
1805 case BuiltinType::ObjCSel: return lldb::eEncodingUint;
1807 case BuiltinType::NullPtr: return lldb::eEncodingUint;
1810 // All pointer types are represented as unsigned integer encodings.
1811 // We may nee to add a eEncodingPointer if we ever need to know the
1813 case clang::Type::ObjCObjectPointer:
1814 case clang::Type::BlockPointer:
1815 case clang::Type::Pointer:
1816 case clang::Type::LValueReference:
1817 case clang::Type::RValueReference:
1818 case clang::Type::MemberPointer: return lldb::eEncodingUint;
1819 case clang::Type::Complex:
1821 lldb::Encoding encoding = lldb::eEncodingIEEE754;
1822 if (qual_type->isComplexType())
1823 encoding = lldb::eEncodingIEEE754;
1826 const ComplexType *complex_type = qual_type->getAsComplexIntegerType();
1828 encoding = ClangASTType(m_ast, complex_type->getElementType()).GetEncoding(count);
1830 encoding = lldb::eEncodingSint;
1836 case clang::Type::ObjCInterface: break;
1837 case clang::Type::Record: break;
1838 case clang::Type::Enum: return lldb::eEncodingSint;
1839 case clang::Type::Typedef:
1840 return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count);
1842 case clang::Type::Elaborated:
1843 return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetEncoding(count);
1845 case clang::Type::Paren:
1846 return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).GetEncoding(count);
1848 case clang::Type::DependentSizedArray:
1849 case clang::Type::DependentSizedExtVector:
1850 case clang::Type::UnresolvedUsing:
1851 case clang::Type::Attributed:
1852 case clang::Type::TemplateTypeParm:
1853 case clang::Type::SubstTemplateTypeParm:
1854 case clang::Type::SubstTemplateTypeParmPack:
1855 case clang::Type::Auto:
1856 case clang::Type::InjectedClassName:
1857 case clang::Type::DependentName:
1858 case clang::Type::DependentTemplateSpecialization:
1859 case clang::Type::PackExpansion:
1860 case clang::Type::ObjCObject:
1862 case clang::Type::TypeOfExpr:
1863 case clang::Type::TypeOf:
1864 case clang::Type::Decltype:
1865 case clang::Type::TemplateSpecialization:
1866 case clang::Type::Atomic:
1871 return lldb::eEncodingInvalid;
1875 ClangASTType::GetFormat () const
1878 return lldb::eFormatDefault;
1880 QualType qual_type(GetCanonicalQualType());
1882 switch (qual_type->getTypeClass())
1884 case clang::Type::UnaryTransform:
1887 case clang::Type::FunctionNoProto:
1888 case clang::Type::FunctionProto:
1891 case clang::Type::IncompleteArray:
1892 case clang::Type::VariableArray:
1895 case clang::Type::ConstantArray:
1896 return lldb::eFormatVoid; // no value
1898 case clang::Type::ExtVector:
1899 case clang::Type::Vector:
1902 case clang::Type::Builtin:
1903 switch (cast<BuiltinType>(qual_type)->getKind())
1905 //default: assert(0 && "Unknown builtin type!");
1906 case BuiltinType::UnknownAny:
1907 case BuiltinType::Void:
1908 case BuiltinType::BoundMember:
1911 case BuiltinType::Bool: return lldb::eFormatBoolean;
1912 case BuiltinType::Char_S:
1913 case BuiltinType::SChar:
1914 case BuiltinType::WChar_S:
1915 case BuiltinType::Char_U:
1916 case BuiltinType::UChar:
1917 case BuiltinType::WChar_U: return lldb::eFormatChar;
1918 case BuiltinType::Char16: return lldb::eFormatUnicode16;
1919 case BuiltinType::Char32: return lldb::eFormatUnicode32;
1920 case BuiltinType::UShort: return lldb::eFormatUnsigned;
1921 case BuiltinType::Short: return lldb::eFormatDecimal;
1922 case BuiltinType::UInt: return lldb::eFormatUnsigned;
1923 case BuiltinType::Int: return lldb::eFormatDecimal;
1924 case BuiltinType::ULong: return lldb::eFormatUnsigned;
1925 case BuiltinType::Long: return lldb::eFormatDecimal;
1926 case BuiltinType::ULongLong: return lldb::eFormatUnsigned;
1927 case BuiltinType::LongLong: return lldb::eFormatDecimal;
1928 case BuiltinType::UInt128: return lldb::eFormatUnsigned;
1929 case BuiltinType::Int128: return lldb::eFormatDecimal;
1930 case BuiltinType::Float: return lldb::eFormatFloat;
1931 case BuiltinType::Double: return lldb::eFormatFloat;
1932 case BuiltinType::LongDouble: return lldb::eFormatFloat;
1933 case BuiltinType::NullPtr:
1934 case BuiltinType::Overload:
1935 case BuiltinType::Dependent:
1936 case BuiltinType::ObjCId:
1937 case BuiltinType::ObjCClass:
1938 case BuiltinType::ObjCSel:
1939 case BuiltinType::Half:
1940 case BuiltinType::ARCUnbridgedCast:
1941 case BuiltinType::PseudoObject:
1942 case BuiltinType::BuiltinFn:
1943 case BuiltinType::OCLEvent:
1944 case BuiltinType::OCLImage1d:
1945 case BuiltinType::OCLImage1dArray:
1946 case BuiltinType::OCLImage1dBuffer:
1947 case BuiltinType::OCLImage2d:
1948 case BuiltinType::OCLImage2dArray:
1949 case BuiltinType::OCLImage3d:
1950 case BuiltinType::OCLSampler:
1951 return lldb::eFormatHex;
1954 case clang::Type::ObjCObjectPointer: return lldb::eFormatHex;
1955 case clang::Type::BlockPointer: return lldb::eFormatHex;
1956 case clang::Type::Pointer: return lldb::eFormatHex;
1957 case clang::Type::LValueReference:
1958 case clang::Type::RValueReference: return lldb::eFormatHex;
1959 case clang::Type::MemberPointer: break;
1960 case clang::Type::Complex:
1962 if (qual_type->isComplexType())
1963 return lldb::eFormatComplex;
1965 return lldb::eFormatComplexInteger;
1967 case clang::Type::ObjCInterface: break;
1968 case clang::Type::Record: break;
1969 case clang::Type::Enum: return lldb::eFormatEnum;
1970 case clang::Type::Typedef:
1971 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetFormat();
1972 case clang::Type::Auto:
1973 return ClangASTType (m_ast, cast<AutoType>(qual_type)->desugar()).GetFormat();
1974 case clang::Type::Paren:
1975 return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetFormat();
1976 case clang::Type::Elaborated:
1977 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetFormat();
1978 case clang::Type::DependentSizedArray:
1979 case clang::Type::DependentSizedExtVector:
1980 case clang::Type::UnresolvedUsing:
1981 case clang::Type::Attributed:
1982 case clang::Type::TemplateTypeParm:
1983 case clang::Type::SubstTemplateTypeParm:
1984 case clang::Type::SubstTemplateTypeParmPack:
1985 case clang::Type::InjectedClassName:
1986 case clang::Type::DependentName:
1987 case clang::Type::DependentTemplateSpecialization:
1988 case clang::Type::PackExpansion:
1989 case clang::Type::ObjCObject:
1991 case clang::Type::TypeOfExpr:
1992 case clang::Type::TypeOf:
1993 case clang::Type::Decltype:
1994 case clang::Type::TemplateSpecialization:
1995 case clang::Type::Atomic:
1998 // We don't know hot to display this type...
1999 return lldb::eFormatBytes;
2003 ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
2005 while (class_interface_decl)
2007 if (class_interface_decl->ivar_size() > 0)
2010 if (check_superclass)
2011 class_interface_decl = class_interface_decl->getSuperClass();
2019 ClangASTType::GetNumChildren (bool omit_empty_base_classes) const
2024 uint32_t num_children = 0;
2025 QualType qual_type(GetQualType());
2026 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2029 case clang::Type::Builtin:
2030 switch (cast<BuiltinType>(qual_type)->getKind())
2032 case BuiltinType::ObjCId: // child is Class
2033 case BuiltinType::ObjCClass: // child is Class
2042 case clang::Type::Complex: return 0;
2044 case clang::Type::Record:
2045 if (GetCompleteQualType (m_ast, qual_type))
2047 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
2048 const RecordDecl *record_decl = record_type->getDecl();
2049 assert(record_decl);
2050 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2051 if (cxx_record_decl)
2053 if (omit_empty_base_classes)
2055 // Check each base classes to see if it or any of its
2056 // base classes contain any fields. This can help
2057 // limit the noise in variable views by not having to
2058 // show base classes that contain no members.
2059 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2060 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2061 base_class != base_class_end;
2064 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2066 // Skip empty base classes
2067 if (ClangASTContext::RecordHasFields(base_class_decl) == false)
2075 // Include all base classes
2076 num_children += cxx_record_decl->getNumBases();
2080 RecordDecl::field_iterator field, field_end;
2081 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
2086 case clang::Type::ObjCObject:
2087 case clang::Type::ObjCInterface:
2088 if (GetCompleteQualType (m_ast, qual_type))
2090 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
2091 assert (objc_class_type);
2092 if (objc_class_type)
2094 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2096 if (class_interface_decl)
2099 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2100 if (superclass_interface_decl)
2102 if (omit_empty_base_classes)
2104 if (ObjCDeclHasIVars (superclass_interface_decl, true))
2111 num_children += class_interface_decl->ivar_size();
2117 case clang::Type::ObjCObjectPointer:
2119 const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr());
2120 QualType pointee_type = pointer_type->getPointeeType();
2121 uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes);
2122 // If this type points to a simple type, then it has 1 child
2123 if (num_pointee_children == 0)
2126 num_children = num_pointee_children;
2130 case clang::Type::Vector:
2131 case clang::Type::ExtVector:
2132 num_children = cast<VectorType>(qual_type.getTypePtr())->getNumElements();
2135 case clang::Type::ConstantArray:
2136 num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
2139 case clang::Type::Pointer:
2141 const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
2142 QualType pointee_type (pointer_type->getPointeeType());
2143 uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes);
2144 if (num_pointee_children == 0)
2146 // We have a pointer to a pointee type that claims it has no children.
2147 // We will want to look at
2148 num_children = ClangASTType (m_ast, pointee_type).GetNumPointeeChildren();
2151 num_children = num_pointee_children;
2155 case clang::Type::LValueReference:
2156 case clang::Type::RValueReference:
2158 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
2159 QualType pointee_type = reference_type->getPointeeType();
2160 uint32_t num_pointee_children = ClangASTType (m_ast, pointee_type).GetNumChildren (omit_empty_base_classes);
2161 // If this type points to a simple type, then it has 1 child
2162 if (num_pointee_children == 0)
2165 num_children = num_pointee_children;
2170 case clang::Type::Typedef:
2171 num_children = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes);
2174 case clang::Type::Elaborated:
2175 num_children = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes);
2178 case clang::Type::Paren:
2179 num_children = ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes);
2184 return num_children;
2188 ClangASTType::GetBasicTypeEnumeration () const
2192 QualType qual_type(GetQualType());
2193 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2194 if (type_class == clang::Type::Builtin)
2196 switch (cast<clang::BuiltinType>(qual_type)->getKind())
2198 case clang::BuiltinType::Void: return eBasicTypeVoid;
2199 case clang::BuiltinType::Bool: return eBasicTypeBool;
2200 case clang::BuiltinType::Char_S: return eBasicTypeSignedChar;
2201 case clang::BuiltinType::Char_U: return eBasicTypeUnsignedChar;
2202 case clang::BuiltinType::Char16: return eBasicTypeChar16;
2203 case clang::BuiltinType::Char32: return eBasicTypeChar32;
2204 case clang::BuiltinType::UChar: return eBasicTypeUnsignedChar;
2205 case clang::BuiltinType::SChar: return eBasicTypeSignedChar;
2206 case clang::BuiltinType::WChar_S: return eBasicTypeSignedWChar;
2207 case clang::BuiltinType::WChar_U: return eBasicTypeUnsignedWChar;
2208 case clang::BuiltinType::Short: return eBasicTypeShort;
2209 case clang::BuiltinType::UShort: return eBasicTypeUnsignedShort;
2210 case clang::BuiltinType::Int: return eBasicTypeInt;
2211 case clang::BuiltinType::UInt: return eBasicTypeUnsignedInt;
2212 case clang::BuiltinType::Long: return eBasicTypeLong;
2213 case clang::BuiltinType::ULong: return eBasicTypeUnsignedLong;
2214 case clang::BuiltinType::LongLong: return eBasicTypeLongLong;
2215 case clang::BuiltinType::ULongLong: return eBasicTypeUnsignedLongLong;
2216 case clang::BuiltinType::Int128: return eBasicTypeInt128;
2217 case clang::BuiltinType::UInt128: return eBasicTypeUnsignedInt128;
2219 case clang::BuiltinType::Half: return eBasicTypeHalf;
2220 case clang::BuiltinType::Float: return eBasicTypeFloat;
2221 case clang::BuiltinType::Double: return eBasicTypeDouble;
2222 case clang::BuiltinType::LongDouble:return eBasicTypeLongDouble;
2224 case clang::BuiltinType::NullPtr: return eBasicTypeNullPtr;
2225 case clang::BuiltinType::ObjCId: return eBasicTypeObjCID;
2226 case clang::BuiltinType::ObjCClass: return eBasicTypeObjCClass;
2227 case clang::BuiltinType::ObjCSel: return eBasicTypeObjCSel;
2228 case clang::BuiltinType::Dependent:
2229 case clang::BuiltinType::Overload:
2230 case clang::BuiltinType::BoundMember:
2231 case clang::BuiltinType::PseudoObject:
2232 case clang::BuiltinType::UnknownAny:
2233 case clang::BuiltinType::BuiltinFn:
2234 case clang::BuiltinType::ARCUnbridgedCast:
2235 case clang::BuiltinType::OCLEvent:
2236 case clang::BuiltinType::OCLImage1d:
2237 case clang::BuiltinType::OCLImage1dArray:
2238 case clang::BuiltinType::OCLImage1dBuffer:
2239 case clang::BuiltinType::OCLImage2d:
2240 case clang::BuiltinType::OCLImage2dArray:
2241 case clang::BuiltinType::OCLImage3d:
2242 case clang::BuiltinType::OCLSampler:
2243 return eBasicTypeOther;
2247 return eBasicTypeInvalid;
2251 #pragma mark Aggregate Types
2254 ClangASTType::GetNumDirectBaseClasses () const
2260 QualType qual_type(GetCanonicalQualType());
2261 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2264 case clang::Type::Record:
2265 if (GetCompleteType())
2267 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2268 if (cxx_record_decl)
2269 count = cxx_record_decl->getNumBases();
2273 case clang::Type::ObjCObjectPointer:
2274 if (GetCompleteType())
2276 const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
2277 if (objc_class_type)
2279 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
2280 if (class_interface_decl && class_interface_decl->getSuperClass())
2286 case clang::Type::ObjCObject:
2287 case clang::Type::ObjCInterface:
2288 if (GetCompleteType())
2290 const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
2291 if (objc_class_type)
2293 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2295 if (class_interface_decl && class_interface_decl->getSuperClass())
2302 case clang::Type::Typedef:
2303 count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumDirectBaseClasses ();
2306 case clang::Type::Elaborated:
2307 count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumDirectBaseClasses ();
2310 case clang::Type::Paren:
2311 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumDirectBaseClasses ();
2320 ClangASTType::GetNumVirtualBaseClasses () const
2326 QualType qual_type(GetCanonicalQualType());
2327 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2330 case clang::Type::Record:
2331 if (GetCompleteType())
2333 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2334 if (cxx_record_decl)
2335 count = cxx_record_decl->getNumVBases();
2339 case clang::Type::Typedef:
2340 count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumVirtualBaseClasses();
2343 case clang::Type::Elaborated:
2344 count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumVirtualBaseClasses();
2347 case clang::Type::Paren:
2348 count = ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumVirtualBaseClasses();
2358 ClangASTType::GetNumFields () const
2364 QualType qual_type(GetCanonicalQualType());
2365 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2368 case clang::Type::Record:
2369 if (GetCompleteType())
2371 const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr());
2374 RecordDecl *record_decl = record_type->getDecl();
2377 uint32_t field_idx = 0;
2378 RecordDecl::field_iterator field, field_end;
2379 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
2387 case clang::Type::Typedef:
2388 count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumFields();
2391 case clang::Type::Elaborated:
2392 count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumFields();
2395 case clang::Type::Paren:
2396 count = ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumFields();
2399 case clang::Type::ObjCObjectPointer:
2400 if (GetCompleteType())
2402 const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
2403 if (objc_class_type)
2405 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
2407 if (class_interface_decl)
2408 count = class_interface_decl->ivar_size();
2413 case clang::Type::ObjCObject:
2414 case clang::Type::ObjCInterface:
2415 if (GetCompleteType())
2417 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
2418 if (objc_class_type)
2420 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2422 if (class_interface_decl)
2423 count = class_interface_decl->ivar_size();
2435 ClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const
2438 return ClangASTType();
2440 QualType qual_type(GetCanonicalQualType());
2441 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2444 case clang::Type::Record:
2445 if (GetCompleteType())
2447 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2448 if (cxx_record_decl)
2450 uint32_t curr_idx = 0;
2451 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2452 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2453 base_class != base_class_end;
2454 ++base_class, ++curr_idx)
2456 if (curr_idx == idx)
2460 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl);
2461 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2462 if (base_class->isVirtual())
2463 *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
2465 *bit_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
2467 return ClangASTType (m_ast, base_class->getType());
2474 case clang::Type::ObjCObjectPointer:
2475 if (idx == 0 && GetCompleteType())
2477 const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
2478 if (objc_class_type)
2480 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
2481 if (class_interface_decl)
2483 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2484 if (superclass_interface_decl)
2487 *bit_offset_ptr = 0;
2488 return ClangASTType (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl));
2495 case clang::Type::ObjCObject:
2496 case clang::Type::ObjCInterface:
2497 if (idx == 0 && GetCompleteType())
2499 const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
2500 if (objc_class_type)
2502 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2504 if (class_interface_decl)
2506 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2507 if (superclass_interface_decl)
2510 *bit_offset_ptr = 0;
2511 return ClangASTType (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl));
2519 case clang::Type::Typedef:
2520 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
2522 case clang::Type::Elaborated:
2523 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
2525 case clang::Type::Paren:
2526 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr);
2531 return ClangASTType();
2535 ClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const
2538 return ClangASTType();
2540 QualType qual_type(GetCanonicalQualType());
2541 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2544 case clang::Type::Record:
2545 if (GetCompleteType())
2547 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2548 if (cxx_record_decl)
2550 uint32_t curr_idx = 0;
2551 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2552 for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end();
2553 base_class != base_class_end;
2554 ++base_class, ++curr_idx)
2556 if (curr_idx == idx)
2560 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl);
2561 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2562 *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
2565 return ClangASTType (m_ast, base_class->getType());
2572 case clang::Type::Typedef:
2573 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
2575 case clang::Type::Elaborated:
2576 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
2578 case clang::Type::Paren:
2579 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr);
2584 return ClangASTType();
2588 GetObjCFieldAtIndex (clang::ASTContext *ast,
2589 ObjCInterfaceDecl *class_interface_decl,
2592 uint64_t *bit_offset_ptr,
2593 uint32_t *bitfield_bit_size_ptr,
2594 bool *is_bitfield_ptr)
2596 if (class_interface_decl)
2598 if (idx < (class_interface_decl->ivar_size()))
2600 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
2601 uint32_t ivar_idx = 0;
2603 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx)
2605 if (ivar_idx == idx)
2607 const ObjCIvarDecl* ivar_decl = *ivar_pos;
2609 QualType ivar_qual_type(ivar_decl->getType());
2611 name.assign(ivar_decl->getNameAsString());
2615 const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
2616 *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx);
2619 const bool is_bitfield = ivar_pos->isBitField();
2621 if (bitfield_bit_size_ptr)
2623 *bitfield_bit_size_ptr = 0;
2625 if (is_bitfield && ast)
2627 Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth();
2628 llvm::APSInt bitfield_apsint;
2629 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast))
2631 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
2635 if (is_bitfield_ptr)
2636 *is_bitfield_ptr = is_bitfield;
2638 return ivar_qual_type.getAsOpaquePtr();
2647 ClangASTType::GetFieldAtIndex (size_t idx,
2649 uint64_t *bit_offset_ptr,
2650 uint32_t *bitfield_bit_size_ptr,
2651 bool *is_bitfield_ptr) const
2654 return ClangASTType();
2656 QualType qual_type(GetCanonicalQualType());
2657 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2660 case clang::Type::Record:
2661 if (GetCompleteType())
2663 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
2664 const RecordDecl *record_decl = record_type->getDecl();
2665 uint32_t field_idx = 0;
2666 RecordDecl::field_iterator field, field_end;
2667 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx)
2669 if (idx == field_idx)
2671 // Print the member type if requested
2672 // Print the member name and equal sign
2673 name.assign(field->getNameAsString());
2675 // Figure out the type byte size (field_type_info.first) and
2676 // alignment (field_type_info.second) from the AST context.
2679 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
2680 *bit_offset_ptr = record_layout.getFieldOffset (field_idx);
2683 const bool is_bitfield = field->isBitField();
2685 if (bitfield_bit_size_ptr)
2687 *bitfield_bit_size_ptr = 0;
2691 Expr *bitfield_bit_size_expr = field->getBitWidth();
2692 llvm::APSInt bitfield_apsint;
2693 if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *m_ast))
2695 *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue();
2699 if (is_bitfield_ptr)
2700 *is_bitfield_ptr = is_bitfield;
2702 return ClangASTType (m_ast, field->getType());
2708 case clang::Type::ObjCObjectPointer:
2709 if (GetCompleteType())
2711 const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType();
2712 if (objc_class_type)
2714 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl();
2715 return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
2720 case clang::Type::ObjCObject:
2721 case clang::Type::ObjCInterface:
2722 if (GetCompleteType())
2724 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
2725 assert (objc_class_type);
2726 if (objc_class_type)
2728 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2729 return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
2735 case clang::Type::Typedef:
2736 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).
2737 GetFieldAtIndex (idx,
2740 bitfield_bit_size_ptr,
2743 case clang::Type::Elaborated:
2744 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).
2745 GetFieldAtIndex (idx,
2748 bitfield_bit_size_ptr,
2751 case clang::Type::Paren:
2752 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).
2753 GetFieldAtIndex (idx,
2756 bitfield_bit_size_ptr,
2762 return ClangASTType();
2766 ClangASTType::GetIndexOfFieldWithName (const char* name,
2767 ClangASTType* field_clang_type_ptr,
2768 uint64_t *bit_offset_ptr,
2769 uint32_t *bitfield_bit_size_ptr,
2770 bool *is_bitfield_ptr) const
2772 unsigned count = GetNumFields();
2773 std::string field_name;
2774 for (unsigned index = 0; index < count; index++)
2776 ClangASTType field_clang_type (GetFieldAtIndex(index, field_name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr));
2777 if (strcmp(field_name.c_str(), name) == 0)
2779 if (field_clang_type_ptr)
2780 *field_clang_type_ptr = field_clang_type;
2787 // If a pointer to a pointee type (the clang_type arg) says that it has no
2788 // children, then we either need to trust it, or override it and return a
2789 // different result. For example, an "int *" has one child that is an integer,
2790 // but a function pointer doesn't have any children. Likewise if a Record type
2791 // claims it has no children, then there really is nothing to show.
2793 ClangASTType::GetNumPointeeChildren () const
2798 QualType qual_type(GetCanonicalQualType());
2799 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2802 case clang::Type::Builtin:
2803 switch (cast<clang::BuiltinType>(qual_type)->getKind())
2805 case clang::BuiltinType::UnknownAny:
2806 case clang::BuiltinType::Void:
2807 case clang::BuiltinType::NullPtr:
2808 case clang::BuiltinType::OCLEvent:
2809 case clang::BuiltinType::OCLImage1d:
2810 case clang::BuiltinType::OCLImage1dArray:
2811 case clang::BuiltinType::OCLImage1dBuffer:
2812 case clang::BuiltinType::OCLImage2d:
2813 case clang::BuiltinType::OCLImage2dArray:
2814 case clang::BuiltinType::OCLImage3d:
2815 case clang::BuiltinType::OCLSampler:
2817 case clang::BuiltinType::Bool:
2818 case clang::BuiltinType::Char_U:
2819 case clang::BuiltinType::UChar:
2820 case clang::BuiltinType::WChar_U:
2821 case clang::BuiltinType::Char16:
2822 case clang::BuiltinType::Char32:
2823 case clang::BuiltinType::UShort:
2824 case clang::BuiltinType::UInt:
2825 case clang::BuiltinType::ULong:
2826 case clang::BuiltinType::ULongLong:
2827 case clang::BuiltinType::UInt128:
2828 case clang::BuiltinType::Char_S:
2829 case clang::BuiltinType::SChar:
2830 case clang::BuiltinType::WChar_S:
2831 case clang::BuiltinType::Short:
2832 case clang::BuiltinType::Int:
2833 case clang::BuiltinType::Long:
2834 case clang::BuiltinType::LongLong:
2835 case clang::BuiltinType::Int128:
2836 case clang::BuiltinType::Float:
2837 case clang::BuiltinType::Double:
2838 case clang::BuiltinType::LongDouble:
2839 case clang::BuiltinType::Dependent:
2840 case clang::BuiltinType::Overload:
2841 case clang::BuiltinType::ObjCId:
2842 case clang::BuiltinType::ObjCClass:
2843 case clang::BuiltinType::ObjCSel:
2844 case clang::BuiltinType::BoundMember:
2845 case clang::BuiltinType::Half:
2846 case clang::BuiltinType::ARCUnbridgedCast:
2847 case clang::BuiltinType::PseudoObject:
2848 case clang::BuiltinType::BuiltinFn:
2853 case clang::Type::Complex: return 1;
2854 case clang::Type::Pointer: return 1;
2855 case clang::Type::BlockPointer: return 0; // If block pointers don't have debug info, then no children for them
2856 case clang::Type::LValueReference: return 1;
2857 case clang::Type::RValueReference: return 1;
2858 case clang::Type::MemberPointer: return 0;
2859 case clang::Type::ConstantArray: return 0;
2860 case clang::Type::IncompleteArray: return 0;
2861 case clang::Type::VariableArray: return 0;
2862 case clang::Type::DependentSizedArray: return 0;
2863 case clang::Type::DependentSizedExtVector: return 0;
2864 case clang::Type::Vector: return 0;
2865 case clang::Type::ExtVector: return 0;
2866 case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children...
2867 case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children...
2868 case clang::Type::UnresolvedUsing: return 0;
2869 case clang::Type::Paren: return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumPointeeChildren ();
2870 case clang::Type::Typedef: return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumPointeeChildren ();
2871 case clang::Type::Elaborated: return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumPointeeChildren ();
2872 case clang::Type::TypeOfExpr: return 0;
2873 case clang::Type::TypeOf: return 0;
2874 case clang::Type::Decltype: return 0;
2875 case clang::Type::Record: return 0;
2876 case clang::Type::Enum: return 1;
2877 case clang::Type::TemplateTypeParm: return 1;
2878 case clang::Type::SubstTemplateTypeParm: return 1;
2879 case clang::Type::TemplateSpecialization: return 1;
2880 case clang::Type::InjectedClassName: return 0;
2881 case clang::Type::DependentName: return 1;
2882 case clang::Type::DependentTemplateSpecialization: return 1;
2883 case clang::Type::ObjCObject: return 0;
2884 case clang::Type::ObjCInterface: return 0;
2885 case clang::Type::ObjCObjectPointer: return 1;
2894 ClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx,
2895 const char *parent_name,
2897 bool transparent_pointers,
2898 bool omit_empty_base_classes,
2899 bool ignore_array_bounds,
2900 std::string& child_name,
2901 uint32_t &child_byte_size,
2902 int32_t &child_byte_offset,
2903 uint32_t &child_bitfield_bit_size,
2904 uint32_t &child_bitfield_bit_offset,
2905 bool &child_is_base_class,
2906 bool &child_is_deref_of_parent) const
2909 return ClangASTType();
2911 QualType parent_qual_type(GetCanonicalQualType());
2912 const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass();
2913 child_bitfield_bit_size = 0;
2914 child_bitfield_bit_offset = 0;
2915 child_is_base_class = false;
2917 const bool idx_is_valid = idx < GetNumChildren (omit_empty_base_classes);
2918 uint32_t bit_offset;
2919 switch (parent_type_class)
2921 case clang::Type::Builtin:
2924 switch (cast<clang::BuiltinType>(parent_qual_type)->getKind())
2926 case clang::BuiltinType::ObjCId:
2927 case clang::BuiltinType::ObjCClass:
2929 child_byte_size = m_ast->getTypeSize(m_ast->ObjCBuiltinClassTy) / CHAR_BIT;
2930 return ClangASTType (m_ast, m_ast->ObjCBuiltinClassTy);
2938 case clang::Type::Record:
2939 if (idx_is_valid && GetCompleteType())
2941 const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr());
2942 const RecordDecl *record_decl = record_type->getDecl();
2943 assert(record_decl);
2944 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
2945 uint32_t child_idx = 0;
2947 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2948 if (cxx_record_decl)
2950 // We might have base classes to print out first
2951 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2952 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2953 base_class != base_class_end;
2956 const CXXRecordDecl *base_class_decl = NULL;
2958 // Skip empty base classes
2959 if (omit_empty_base_classes)
2961 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2962 if (ClangASTContext::RecordHasFields(base_class_decl) == false)
2966 if (idx == child_idx)
2968 if (base_class_decl == NULL)
2969 base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2972 if (base_class->isVirtual())
2973 bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
2975 bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
2977 // Base classes should be a multiple of 8 bits in size
2978 child_byte_offset = bit_offset/8;
2979 ClangASTType base_class_clang_type(m_ast, base_class->getType());
2980 child_name = base_class_clang_type.GetTypeName();
2981 uint64_t base_class_clang_type_bit_size = base_class_clang_type.GetBitSize();
2983 // Base classes bit sizes should be a multiple of 8 bits in size
2984 assert (base_class_clang_type_bit_size % 8 == 0);
2985 child_byte_size = base_class_clang_type_bit_size / 8;
2986 child_is_base_class = true;
2987 return base_class_clang_type;
2989 // We don't increment the child index in the for loop since we might
2990 // be skipping empty base classes
2994 // Make sure index is in range...
2995 uint32_t field_idx = 0;
2996 RecordDecl::field_iterator field, field_end;
2997 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
2999 if (idx == child_idx)
3001 // Print the member type if requested
3002 // Print the member name and equal sign
3003 child_name.assign(field->getNameAsString().c_str());
3005 // Figure out the type byte size (field_type_info.first) and
3006 // alignment (field_type_info.second) from the AST context.
3007 ClangASTType field_clang_type (m_ast, field->getType());
3008 assert(field_idx < record_layout.getFieldCount());
3009 child_byte_size = field_clang_type.GetByteSize();
3011 // Figure out the field offset within the current struct/union/class type
3012 bit_offset = record_layout.getFieldOffset (field_idx);
3013 child_byte_offset = bit_offset / 8;
3014 if (ClangASTContext::FieldIsBitfield (m_ast, *field, child_bitfield_bit_size))
3015 child_bitfield_bit_offset = bit_offset % 8;
3017 return field_clang_type;
3023 case clang::Type::ObjCObject:
3024 case clang::Type::ObjCInterface:
3025 if (idx_is_valid && GetCompleteType())
3027 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr());
3028 assert (objc_class_type);
3029 if (objc_class_type)
3031 uint32_t child_idx = 0;
3032 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3034 if (class_interface_decl)
3037 const ASTRecordLayout &interface_layout = m_ast->getASTObjCInterfaceLayout(class_interface_decl);
3038 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3039 if (superclass_interface_decl)
3041 if (omit_empty_base_classes)
3043 ClangASTType base_class_clang_type (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl));
3044 if (base_class_clang_type.GetNumChildren(omit_empty_base_classes) > 0)
3048 QualType ivar_qual_type(m_ast->getObjCInterfaceType(superclass_interface_decl));
3051 child_name.assign(superclass_interface_decl->getNameAsString().c_str());
3053 std::pair<uint64_t, unsigned> ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr());
3055 child_byte_size = ivar_type_info.first / 8;
3056 child_byte_offset = 0;
3057 child_is_base_class = true;
3059 return ClangASTType (m_ast, ivar_qual_type);
3069 const uint32_t superclass_idx = child_idx;
3071 if (idx < (child_idx + class_interface_decl->ivar_size()))
3073 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3075 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
3077 if (child_idx == idx)
3079 ObjCIvarDecl* ivar_decl = *ivar_pos;
3081 QualType ivar_qual_type(ivar_decl->getType());
3083 child_name.assign(ivar_decl->getNameAsString().c_str());
3085 std::pair<uint64_t, unsigned> ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr());
3087 child_byte_size = ivar_type_info.first / 8;
3089 // Figure out the field offset within the current struct/union/class type
3090 // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since
3091 // that doesn't account for the space taken up by unbacked properties, or from
3092 // the changing size of base classes that are newer than this class.
3093 // So if we have a process around that we can ask about this object, do so.
3094 child_byte_offset = LLDB_INVALID_IVAR_OFFSET;
3095 Process *process = NULL;
3097 process = exe_ctx->GetProcessPtr();
3100 ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
3101 if (objc_runtime != NULL)
3103 ClangASTType parent_ast_type (m_ast, parent_qual_type);
3104 child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str());
3108 // Setting this to UINT32_MAX to make sure we don't compute it twice...
3109 bit_offset = UINT32_MAX;
3111 if (child_byte_offset == LLDB_INVALID_IVAR_OFFSET)
3113 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
3114 child_byte_offset = bit_offset / 8;
3117 // Note, the ObjC Ivar Byte offset is just that, it doesn't account for the bit offset
3118 // of a bitfield within its containing object. So regardless of where we get the byte
3119 // offset from, we still need to get the bit offset for bitfields from the layout.
3121 if (ClangASTContext::FieldIsBitfield (m_ast, ivar_decl, child_bitfield_bit_size))
3123 if (bit_offset == UINT32_MAX)
3124 bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
3126 child_bitfield_bit_offset = bit_offset % 8;
3128 return ClangASTType (m_ast, ivar_qual_type);
3138 case clang::Type::ObjCObjectPointer:
3141 ClangASTType pointee_clang_type (GetPointeeType());
3143 if (transparent_pointers && pointee_clang_type.IsAggregateType())
3145 child_is_deref_of_parent = false;
3146 bool tmp_child_is_deref_of_parent = false;
3147 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3150 transparent_pointers,
3151 omit_empty_base_classes,
3152 ignore_array_bounds,
3156 child_bitfield_bit_size,
3157 child_bitfield_bit_offset,
3158 child_is_base_class,
3159 tmp_child_is_deref_of_parent);
3163 child_is_deref_of_parent = true;
3166 child_name.assign(1, '*');
3167 child_name += parent_name;
3170 // We have a pointer to an simple type
3171 if (idx == 0 && pointee_clang_type.GetCompleteType())
3173 child_byte_size = pointee_clang_type.GetByteSize();
3174 child_byte_offset = 0;
3175 return pointee_clang_type;
3181 case clang::Type::Vector:
3182 case clang::Type::ExtVector:
3185 const VectorType *array = cast<VectorType>(parent_qual_type.getTypePtr());
3188 ClangASTType element_type (m_ast, array->getElementType());
3189 if (element_type.GetCompleteType())
3191 char element_name[64];
3192 ::snprintf (element_name, sizeof (element_name), "[%zu]", idx);
3193 child_name.assign(element_name);
3194 child_byte_size = element_type.GetByteSize();
3195 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
3196 return element_type;
3202 case clang::Type::ConstantArray:
3203 case clang::Type::IncompleteArray:
3204 if (ignore_array_bounds || idx_is_valid)
3206 const ArrayType *array = cast<ArrayType>(parent_qual_type.getTypePtr());
3209 ClangASTType element_type (m_ast, array->getElementType());
3210 if (element_type.GetCompleteType())
3212 char element_name[64];
3213 ::snprintf (element_name, sizeof (element_name), "[%zu]", idx);
3214 child_name.assign(element_name);
3215 child_byte_size = element_type.GetByteSize();
3216 child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
3217 return element_type;
3224 case clang::Type::Pointer:
3227 ClangASTType pointee_clang_type (GetPointeeType());
3229 // Don't dereference "void *" pointers
3230 if (pointee_clang_type.IsVoidType())
3231 return ClangASTType();
3233 if (transparent_pointers && pointee_clang_type.IsAggregateType ())
3235 child_is_deref_of_parent = false;
3236 bool tmp_child_is_deref_of_parent = false;
3237 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3240 transparent_pointers,
3241 omit_empty_base_classes,
3242 ignore_array_bounds,
3246 child_bitfield_bit_size,
3247 child_bitfield_bit_offset,
3248 child_is_base_class,
3249 tmp_child_is_deref_of_parent);
3253 child_is_deref_of_parent = true;
3257 child_name.assign(1, '*');
3258 child_name += parent_name;
3261 // We have a pointer to an simple type
3264 child_byte_size = pointee_clang_type.GetByteSize();
3265 child_byte_offset = 0;
3266 return pointee_clang_type;
3272 case clang::Type::LValueReference:
3273 case clang::Type::RValueReference:
3276 const ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr());
3277 ClangASTType pointee_clang_type (m_ast, reference_type->getPointeeType());
3278 if (transparent_pointers && pointee_clang_type.IsAggregateType ())
3280 child_is_deref_of_parent = false;
3281 bool tmp_child_is_deref_of_parent = false;
3282 return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3285 transparent_pointers,
3286 omit_empty_base_classes,
3287 ignore_array_bounds,
3291 child_bitfield_bit_size,
3292 child_bitfield_bit_offset,
3293 child_is_base_class,
3294 tmp_child_is_deref_of_parent);
3300 child_name.assign(1, '&');
3301 child_name += parent_name;
3304 // We have a pointer to an simple type
3307 child_byte_size = pointee_clang_type.GetByteSize();
3308 child_byte_offset = 0;
3309 return pointee_clang_type;
3315 case clang::Type::Typedef:
3317 ClangASTType typedefed_clang_type (m_ast, cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType());
3318 return typedefed_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3321 transparent_pointers,
3322 omit_empty_base_classes,
3323 ignore_array_bounds,
3327 child_bitfield_bit_size,
3328 child_bitfield_bit_offset,
3329 child_is_base_class,
3330 child_is_deref_of_parent);
3334 case clang::Type::Elaborated:
3336 ClangASTType elaborated_clang_type (m_ast, cast<ElaboratedType>(parent_qual_type)->getNamedType());
3337 return elaborated_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3340 transparent_pointers,
3341 omit_empty_base_classes,
3342 ignore_array_bounds,
3346 child_bitfield_bit_size,
3347 child_bitfield_bit_offset,
3348 child_is_base_class,
3349 child_is_deref_of_parent);
3352 case clang::Type::Paren:
3354 ClangASTType paren_clang_type (m_ast, llvm::cast<clang::ParenType>(parent_qual_type)->desugar());
3355 return paren_clang_type.GetChildClangTypeAtIndex (exe_ctx,
3358 transparent_pointers,
3359 omit_empty_base_classes,
3360 ignore_array_bounds,
3364 child_bitfield_bit_size,
3365 child_bitfield_bit_offset,
3366 child_is_base_class,
3367 child_is_deref_of_parent);
3374 return ClangASTType();
3378 BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
3380 return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
3384 GetIndexForRecordBase
3386 const RecordDecl *record_decl,
3387 const CXXBaseSpecifier *base_spec,
3388 bool omit_empty_base_classes
3391 uint32_t child_idx = 0;
3393 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3395 // const char *super_name = record_decl->getNameAsCString();
3396 // const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString();
3397 // printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
3399 if (cxx_record_decl)
3401 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3402 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3403 base_class != base_class_end;
3406 if (omit_empty_base_classes)
3408 if (BaseSpecifierIsEmpty (base_class))
3412 // printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name,
3414 // base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
3417 if (base_class == base_spec)
3428 GetIndexForRecordChild (const RecordDecl *record_decl,
3429 NamedDecl *canonical_decl,
3430 bool omit_empty_base_classes)
3432 uint32_t child_idx = ClangASTContext::GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl),
3433 omit_empty_base_classes);
3435 RecordDecl::field_iterator field, field_end;
3436 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3438 ++field, ++child_idx)
3440 if (field->getCanonicalDecl() == canonical_decl)
3447 // Look for a child member (doesn't include base classes, but it does include
3448 // their members) in the type hierarchy. Returns an index path into "clang_type"
3449 // on how to reach the appropriate member.
3468 // If we have a clang type that describes "class C", and we wanted to looked
3471 // With omit_empty_base_classes == false we would get an integer array back with:
3473 // The first index 1 is the child index for "class A" within class C
3474 // The second index 1 is the child index for "m_b" within class A
3476 // With omit_empty_base_classes == true we would get an integer array back with:
3478 // The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count)
3479 // The second index 1 is the child index for "m_b" within class A
3482 ClangASTType::GetIndexOfChildMemberWithName (const char *name,
3483 bool omit_empty_base_classes,
3484 std::vector<uint32_t>& child_indexes) const
3486 if (IsValid() && name && name[0])
3488 QualType qual_type(GetCanonicalQualType());
3489 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3492 case clang::Type::Record:
3493 if (GetCompleteType ())
3495 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
3496 const RecordDecl *record_decl = record_type->getDecl();
3498 assert(record_decl);
3499 uint32_t child_idx = 0;
3501 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3503 // Try and find a field that matches NAME
3504 RecordDecl::field_iterator field, field_end;
3505 StringRef name_sref(name);
3506 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3508 ++field, ++child_idx)
3510 if (field->getName().equals (name_sref))
3512 // We have to add on the number of base classes to this index!
3513 child_indexes.push_back (child_idx + ClangASTContext::GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes));
3514 return child_indexes.size();
3518 if (cxx_record_decl)
3520 const RecordDecl *parent_record_decl = cxx_record_decl;
3522 //printf ("parent = %s\n", parent_record_decl->getNameAsCString());
3524 //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
3525 // Didn't find things easily, lets let clang do its thang...
3526 IdentifierInfo & ident_ref = m_ast->Idents.get(name_sref);
3527 DeclarationName decl_name(&ident_ref);
3530 if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember,
3531 decl_name.getAsOpaquePtr(),
3534 CXXBasePaths::const_paths_iterator path, path_end = paths.end();
3535 for (path = paths.begin(); path != path_end; ++path)
3537 const size_t num_path_elements = path->size();
3538 for (size_t e=0; e<num_path_elements; ++e)
3540 CXXBasePathElement elem = (*path)[e];
3542 child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes);
3543 if (child_idx == UINT32_MAX)
3545 child_indexes.clear();
3550 child_indexes.push_back (child_idx);
3551 parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl());
3554 for (NamedDecl *path_decl : path->Decls)
3556 child_idx = GetIndexForRecordChild (parent_record_decl, path_decl, omit_empty_base_classes);
3557 if (child_idx == UINT32_MAX)
3559 child_indexes.clear();
3564 child_indexes.push_back (child_idx);
3568 return child_indexes.size();
3575 case clang::Type::ObjCObject:
3576 case clang::Type::ObjCInterface:
3577 if (GetCompleteType ())
3579 StringRef name_sref(name);
3580 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3581 assert (objc_class_type);
3582 if (objc_class_type)
3584 uint32_t child_idx = 0;
3585 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3587 if (class_interface_decl)
3589 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3590 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3592 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
3594 const ObjCIvarDecl* ivar_decl = *ivar_pos;
3596 if (ivar_decl->getName().equals (name_sref))
3598 if ((!omit_empty_base_classes && superclass_interface_decl) ||
3599 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
3602 child_indexes.push_back (child_idx);
3603 return child_indexes.size();
3607 if (superclass_interface_decl)
3609 // The super class index is always zero for ObjC classes,
3610 // so we push it onto the child indexes in case we find
3611 // an ivar in our superclass...
3612 child_indexes.push_back (0);
3614 ClangASTType superclass_clang_type (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl));
3615 if (superclass_clang_type.GetIndexOfChildMemberWithName (name,
3616 omit_empty_base_classes,
3619 // We did find an ivar in a superclass so just
3620 // return the results!
3621 return child_indexes.size();
3624 // We didn't find an ivar matching "name" in our
3625 // superclass, pop the superclass zero index that
3626 // we pushed on above.
3627 child_indexes.pop_back();
3634 case clang::Type::ObjCObjectPointer:
3636 ClangASTType objc_object_clang_type (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
3637 return objc_object_clang_type.GetIndexOfChildMemberWithName (name,
3638 omit_empty_base_classes,
3644 case clang::Type::ConstantArray:
3646 // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
3647 // const uint64_t element_count = array->getSize().getLimitedValue();
3649 // if (idx < element_count)
3651 // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
3653 // char element_name[32];
3654 // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
3656 // child_name.assign(element_name);
3657 // assert(field_type_info.first % 8 == 0);
3658 // child_byte_size = field_type_info.first / 8;
3659 // child_byte_offset = idx * child_byte_size;
3660 // return array->getElementType().getAsOpaquePtr();
3665 // case clang::Type::MemberPointerType:
3667 // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
3668 // QualType pointee_type = mem_ptr_type->getPointeeType();
3670 // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3672 // return GetIndexOfChildWithName (ast,
3673 // mem_ptr_type->getPointeeType().getAsOpaquePtr(),
3679 case clang::Type::LValueReference:
3680 case clang::Type::RValueReference:
3682 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3683 QualType pointee_type(reference_type->getPointeeType());
3684 ClangASTType pointee_clang_type (m_ast, pointee_type);
3686 if (pointee_clang_type.IsAggregateType ())
3688 return pointee_clang_type.GetIndexOfChildMemberWithName (name,
3689 omit_empty_base_classes,
3695 case clang::Type::Pointer:
3697 ClangASTType pointee_clang_type (GetPointeeType());
3699 if (pointee_clang_type.IsAggregateType ())
3701 return pointee_clang_type.GetIndexOfChildMemberWithName (name,
3702 omit_empty_base_classes,
3708 case clang::Type::Typedef:
3709 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name,
3710 omit_empty_base_classes,
3713 case clang::Type::Elaborated:
3714 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name,
3715 omit_empty_base_classes,
3718 case clang::Type::Paren:
3719 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildMemberWithName (name,
3720 omit_empty_base_classes,
3731 // Get the index of the child of "clang_type" whose name matches. This function
3732 // doesn't descend into the children, but only looks one level deep and name
3733 // matches can include base class names.
3736 ClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_classes) const
3738 if (IsValid() && name && name[0])
3740 QualType qual_type(GetCanonicalQualType());
3742 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3746 case clang::Type::Record:
3747 if (GetCompleteType ())
3749 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
3750 const RecordDecl *record_decl = record_type->getDecl();
3752 assert(record_decl);
3753 uint32_t child_idx = 0;
3755 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3757 if (cxx_record_decl)
3759 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3760 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3761 base_class != base_class_end;
3764 // Skip empty base classes
3765 CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3766 if (omit_empty_base_classes && ClangASTContext::RecordHasFields(base_class_decl) == false)
3769 ClangASTType base_class_clang_type (m_ast, base_class->getType());
3770 std::string base_class_type_name (base_class_clang_type.GetTypeName());
3771 if (base_class_type_name.compare (name) == 0)
3777 // Try and find a field that matches NAME
3778 RecordDecl::field_iterator field, field_end;
3779 StringRef name_sref(name);
3780 for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3782 ++field, ++child_idx)
3784 if (field->getName().equals (name_sref))
3791 case clang::Type::ObjCObject:
3792 case clang::Type::ObjCInterface:
3793 if (GetCompleteType())
3795 StringRef name_sref(name);
3796 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3797 assert (objc_class_type);
3798 if (objc_class_type)
3800 uint32_t child_idx = 0;
3801 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3803 if (class_interface_decl)
3805 ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3806 ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3808 for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
3810 const ObjCIvarDecl* ivar_decl = *ivar_pos;
3812 if (ivar_decl->getName().equals (name_sref))
3814 if ((!omit_empty_base_classes && superclass_interface_decl) ||
3815 ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
3822 if (superclass_interface_decl)
3824 if (superclass_interface_decl->getName().equals (name_sref))
3832 case clang::Type::ObjCObjectPointer:
3834 ClangASTType pointee_clang_type (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType());
3835 return pointee_clang_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
3839 case clang::Type::ConstantArray:
3841 // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
3842 // const uint64_t element_count = array->getSize().getLimitedValue();
3844 // if (idx < element_count)
3846 // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
3848 // char element_name[32];
3849 // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
3851 // child_name.assign(element_name);
3852 // assert(field_type_info.first % 8 == 0);
3853 // child_byte_size = field_type_info.first / 8;
3854 // child_byte_offset = idx * child_byte_size;
3855 // return array->getElementType().getAsOpaquePtr();
3860 // case clang::Type::MemberPointerType:
3862 // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
3863 // QualType pointee_type = mem_ptr_type->getPointeeType();
3865 // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3867 // return GetIndexOfChildWithName (ast,
3868 // mem_ptr_type->getPointeeType().getAsOpaquePtr(),
3874 case clang::Type::LValueReference:
3875 case clang::Type::RValueReference:
3877 const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3878 ClangASTType pointee_type (m_ast, reference_type->getPointeeType());
3880 if (pointee_type.IsAggregateType ())
3882 return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
3887 case clang::Type::Pointer:
3889 const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
3890 ClangASTType pointee_type (m_ast, pointer_type->getPointeeType());
3892 if (pointee_type.IsAggregateType ())
3894 return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes);
3900 // child_name.assign(1, '*');
3901 // child_name += parent_name;
3904 // // We have a pointer to an simple type
3907 // std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
3908 // assert(clang_type_info.first % 8 == 0);
3909 // child_byte_size = clang_type_info.first / 8;
3910 // child_byte_offset = 0;
3911 // return pointee_type.getAsOpaquePtr();
3917 case clang::Type::Elaborated:
3918 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
3920 case clang::Type::Paren:
3921 return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes);
3923 case clang::Type::Typedef:
3924 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes);
3935 ClangASTType::GetNumTemplateArguments () const
3939 QualType qual_type (GetCanonicalQualType());
3941 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3944 case clang::Type::Record:
3945 if (GetCompleteType ())
3947 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3948 if (cxx_record_decl)
3950 const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl);
3952 return template_decl->getTemplateArgs().size();
3957 case clang::Type::Typedef:
3958 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumTemplateArguments();
3960 case clang::Type::Elaborated:
3961 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumTemplateArguments();
3963 case clang::Type::Paren:
3964 return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetNumTemplateArguments();
3974 ClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &kind) const
3978 QualType qual_type (GetCanonicalQualType());
3980 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3983 case clang::Type::Record:
3984 if (GetCompleteType ())
3986 const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3987 if (cxx_record_decl)
3989 const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl);
3990 if (template_decl && arg_idx < template_decl->getTemplateArgs().size())
3992 const TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx];
3993 switch (template_arg.getKind())
3995 case clang::TemplateArgument::Null:
3996 kind = eTemplateArgumentKindNull;
3997 return ClangASTType();
3999 case clang::TemplateArgument::Type:
4000 kind = eTemplateArgumentKindType;
4001 return ClangASTType(m_ast, template_arg.getAsType());
4003 case clang::TemplateArgument::Declaration:
4004 kind = eTemplateArgumentKindDeclaration;
4005 return ClangASTType();
4007 case clang::TemplateArgument::Integral:
4008 kind = eTemplateArgumentKindIntegral;
4009 return ClangASTType(m_ast, template_arg.getIntegralType());
4011 case clang::TemplateArgument::Template:
4012 kind = eTemplateArgumentKindTemplate;
4013 return ClangASTType();
4015 case clang::TemplateArgument::TemplateExpansion:
4016 kind = eTemplateArgumentKindTemplateExpansion;
4017 return ClangASTType();
4019 case clang::TemplateArgument::Expression:
4020 kind = eTemplateArgumentKindExpression;
4021 return ClangASTType();
4023 case clang::TemplateArgument::Pack:
4024 kind = eTemplateArgumentKindPack;
4025 return ClangASTType();
4028 assert (!"Unhandled TemplateArgument::ArgKind");
4036 case clang::Type::Typedef:
4037 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTemplateArgument (arg_idx, kind);
4039 case clang::Type::Elaborated:
4040 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTemplateArgument (arg_idx, kind);
4042 case clang::Type::Paren:
4043 return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetTemplateArgument (arg_idx, kind);
4049 kind = eTemplateArgumentKindNull;
4050 return ClangASTType ();
4054 IsOperator (const char *name, OverloadedOperatorKind &op_kind)
4056 if (name == NULL || name[0] == '\0')
4059 #define OPERATOR_PREFIX "operator"
4060 #define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
4062 const char *post_op_name = NULL;
4064 bool no_space = true;
4066 if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
4069 post_op_name = name + OPERATOR_PREFIX_LENGTH;
4071 if (post_op_name[0] == ' ')
4077 #undef OPERATOR_PREFIX
4078 #undef OPERATOR_PREFIX_LENGTH
4080 // This is an operator, set the overloaded operator kind to invalid
4081 // in case this is a conversion operator...
4082 op_kind = NUM_OVERLOADED_OPERATORS;
4084 switch (post_op_name[0])
4093 if (strcmp (post_op_name, "new") == 0)
4095 else if (strcmp (post_op_name, "new[]") == 0)
4096 op_kind = OO_Array_New;
4102 if (strcmp (post_op_name, "delete") == 0)
4103 op_kind = OO_Delete;
4104 else if (strcmp (post_op_name, "delete[]") == 0)
4105 op_kind = OO_Array_Delete;
4109 if (post_op_name[1] == '\0')
4111 else if (post_op_name[2] == '\0')
4113 if (post_op_name[1] == '=')
4114 op_kind = OO_PlusEqual;
4115 else if (post_op_name[1] == '+')
4116 op_kind = OO_PlusPlus;
4121 if (post_op_name[1] == '\0')
4123 else if (post_op_name[2] == '\0')
4125 switch (post_op_name[1])
4127 case '=': op_kind = OO_MinusEqual; break;
4128 case '-': op_kind = OO_MinusMinus; break;
4129 case '>': op_kind = OO_Arrow; break;
4132 else if (post_op_name[3] == '\0')
4134 if (post_op_name[2] == '*')
4135 op_kind = OO_ArrowStar; break;
4140 if (post_op_name[1] == '\0')
4142 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4143 op_kind = OO_StarEqual;
4147 if (post_op_name[1] == '\0')
4149 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4150 op_kind = OO_SlashEqual;
4154 if (post_op_name[1] == '\0')
4155 op_kind = OO_Percent;
4156 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4157 op_kind = OO_PercentEqual;
4162 if (post_op_name[1] == '\0')
4164 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4165 op_kind = OO_CaretEqual;
4169 if (post_op_name[1] == '\0')
4171 else if (post_op_name[2] == '\0')
4173 switch (post_op_name[1])
4175 case '=': op_kind = OO_AmpEqual; break;
4176 case '&': op_kind = OO_AmpAmp; break;
4182 if (post_op_name[1] == '\0')
4184 else if (post_op_name[2] == '\0')
4186 switch (post_op_name[1])
4188 case '=': op_kind = OO_PipeEqual; break;
4189 case '|': op_kind = OO_PipePipe; break;
4195 if (post_op_name[1] == '\0')
4200 if (post_op_name[1] == '\0')
4201 op_kind = OO_Exclaim;
4202 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4203 op_kind = OO_ExclaimEqual;
4207 if (post_op_name[1] == '\0')
4209 else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
4210 op_kind = OO_EqualEqual;
4214 if (post_op_name[1] == '\0')
4216 else if (post_op_name[2] == '\0')
4218 switch (post_op_name[1])
4220 case '<': op_kind = OO_LessLess; break;
4221 case '=': op_kind = OO_LessEqual; break;
4224 else if (post_op_name[3] == '\0')
4226 if (post_op_name[2] == '=')
4227 op_kind = OO_LessLessEqual;
4232 if (post_op_name[1] == '\0')
4233 op_kind = OO_Greater;
4234 else if (post_op_name[2] == '\0')
4236 switch (post_op_name[1])
4238 case '>': op_kind = OO_GreaterGreater; break;
4239 case '=': op_kind = OO_GreaterEqual; break;
4242 else if (post_op_name[1] == '>' &&
4243 post_op_name[2] == '=' &&
4244 post_op_name[3] == '\0')
4246 op_kind = OO_GreaterGreaterEqual;
4251 if (post_op_name[1] == '\0')
4256 if (post_op_name[1] == ')' && post_op_name[2] == '\0')
4261 if (post_op_name[1] == ']' && post_op_name[2] == '\0')
4262 op_kind = OO_Subscript;
4270 check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params)
4272 // Special-case call since it can take any number of operands
4273 if(op_kind == OO_Call)
4276 // The parameter count doens't include "this"
4277 if (num_params == 0)
4279 if (num_params == 1)
4286 ClangASTType::GetAsRecordDecl () const
4288 const RecordType *record_type = dyn_cast<RecordType>(GetCanonicalQualType());
4290 return record_type->getDecl();
4294 clang::CXXRecordDecl *
4295 ClangASTType::GetAsCXXRecordDecl () const
4297 return GetCanonicalQualType()->getAsCXXRecordDecl();
4301 ClangASTType::GetAsObjCInterfaceDecl () const
4303 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(GetCanonicalQualType());
4304 if (objc_class_type)
4305 return objc_class_type->getInterface();
4310 ClangASTType::AddFieldToRecordType (const char *name,
4311 const ClangASTType &field_clang_type,
4313 uint32_t bitfield_bit_size)
4315 if (!IsValid() || !field_clang_type.IsValid())
4318 FieldDecl *field = NULL;
4320 clang::Expr *bit_width = NULL;
4321 if (bitfield_bit_size != 0)
4323 APInt bitfield_bit_size_apint(m_ast->getTypeSize(m_ast->IntTy), bitfield_bit_size);
4324 bit_width = new (*m_ast)IntegerLiteral (*m_ast, bitfield_bit_size_apint, m_ast->IntTy, SourceLocation());
4327 RecordDecl *record_decl = GetAsRecordDecl ();
4330 field = FieldDecl::Create (*m_ast,
4334 name ? &m_ast->Idents.get(name) : NULL, // Identifier
4335 field_clang_type.GetQualType(), // Field type
4337 bit_width, // BitWidth
4339 ICIS_NoInit); // HasInit
4343 // Determine whether this field corresponds to an anonymous
4345 if (const TagType *TagT = field->getType()->getAs<TagType>()) {
4346 if (RecordDecl *Rec = dyn_cast<RecordDecl>(TagT->getDecl()))
4347 if (!Rec->getDeclName()) {
4348 Rec->setAnonymousStructOrUnion(true);
4349 field->setImplicit();
4357 field->setAccess (ClangASTContext::ConvertAccessTypeToAccessSpecifier (access));
4359 record_decl->addDecl(field);
4361 #ifdef LLDB_CONFIGURATION_DEBUG
4368 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
4370 if (class_interface_decl)
4372 const bool is_synthesized = false;
4374 field_clang_type.GetCompleteType();
4376 field = ObjCIvarDecl::Create (*m_ast,
4377 class_interface_decl,
4380 name ? &m_ast->Idents.get(name) : NULL, // Identifier
4381 field_clang_type.GetQualType(), // Field type
4382 NULL, // TypeSourceInfo *
4383 ConvertAccessTypeToObjCIvarAccessControl (access),
4389 class_interface_decl->addDecl(field);
4391 #ifdef LLDB_CONFIGURATION_DEBUG
4401 ClangASTType::BuildIndirectFields ()
4403 RecordDecl *record_decl = GetAsRecordDecl();
4408 typedef llvm::SmallVector <IndirectFieldDecl *, 1> IndirectFieldVector;
4410 IndirectFieldVector indirect_fields;
4411 RecordDecl::field_iterator field_pos;
4412 RecordDecl::field_iterator field_end_pos = record_decl->field_end();
4413 RecordDecl::field_iterator last_field_pos = field_end_pos;
4414 for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; last_field_pos = field_pos++)
4416 if (field_pos->isAnonymousStructOrUnion())
4418 QualType field_qual_type = field_pos->getType();
4420 const RecordType *field_record_type = field_qual_type->getAs<RecordType>();
4422 if (!field_record_type)
4425 RecordDecl *field_record_decl = field_record_type->getDecl();
4427 if (!field_record_decl)
4430 for (RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end();
4434 if (FieldDecl *nested_field_decl = dyn_cast<FieldDecl>(*di))
4436 NamedDecl **chain = new (*m_ast) NamedDecl*[2];
4437 chain[0] = *field_pos;
4438 chain[1] = nested_field_decl;
4439 IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast,
4442 nested_field_decl->getIdentifier(),
4443 nested_field_decl->getType(),
4447 indirect_field->setImplicit();
4449 indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(),
4450 nested_field_decl->getAccess()));
4452 indirect_fields.push_back(indirect_field);
4454 else if (IndirectFieldDecl *nested_indirect_field_decl = dyn_cast<IndirectFieldDecl>(*di))
4456 int nested_chain_size = nested_indirect_field_decl->getChainingSize();
4457 NamedDecl **chain = new (*m_ast) NamedDecl*[nested_chain_size + 1];
4458 chain[0] = *field_pos;
4460 int chain_index = 1;
4461 for (IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(),
4462 nce = nested_indirect_field_decl->chain_end();
4466 chain[chain_index] = *nci;
4470 IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast,
4473 nested_indirect_field_decl->getIdentifier(),
4474 nested_indirect_field_decl->getType(),
4476 nested_chain_size + 1);
4478 indirect_field->setImplicit();
4480 indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(),
4481 nested_indirect_field_decl->getAccess()));
4483 indirect_fields.push_back(indirect_field);
4489 // Check the last field to see if it has an incomplete array type as its
4490 // last member and if it does, the tell the record decl about it
4491 if (last_field_pos != field_end_pos)
4493 if (last_field_pos->getType()->isIncompleteArrayType())
4494 record_decl->hasFlexibleArrayMember();
4497 for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), ife = indirect_fields.end();
4501 record_decl->addDecl(*ifi);
4506 ClangASTType::AddVariableToRecordType (const char *name,
4507 const ClangASTType &var_type,
4510 clang::VarDecl *var_decl = NULL;
4512 if (!IsValid() || !var_type.IsValid())
4515 RecordDecl *record_decl = GetAsRecordDecl ();
4518 var_decl = VarDecl::Create (*m_ast, // ASTContext &
4519 record_decl, // DeclContext *
4520 SourceLocation(), // SourceLocation StartLoc
4521 SourceLocation(), // SourceLocation IdLoc
4522 name ? &m_ast->Idents.get(name) : NULL, // IdentifierInfo *
4523 var_type.GetQualType(), // Variable QualType
4524 NULL, // TypeSourceInfo *
4525 SC_Static); // StorageClass
4528 var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access));
4529 record_decl->addDecl(var_decl);
4531 #ifdef LLDB_CONFIGURATION_DEBUG
4532 VerifyDecl(var_decl);
4541 ClangASTType::AddMethodToCXXRecordType (const char *name,
4542 const ClangASTType &method_clang_type,
4543 lldb::AccessType access,
4551 if (!IsValid() || !method_clang_type.IsValid() || name == NULL || name[0] == '\0')
4554 QualType record_qual_type(GetCanonicalQualType());
4556 CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
4558 if (cxx_record_decl == NULL)
4561 QualType method_qual_type (method_clang_type.GetQualType());
4563 CXXMethodDecl *cxx_method_decl = NULL;
4565 DeclarationName decl_name (&m_ast->Idents.get(name));
4567 const clang::FunctionType *function_type = dyn_cast<FunctionType>(method_qual_type.getTypePtr());
4569 if (function_type == NULL)
4572 const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_type));
4574 if (!method_function_prototype)
4577 unsigned int num_params = method_function_prototype->getNumArgs();
4579 CXXDestructorDecl *cxx_dtor_decl(NULL);
4580 CXXConstructorDecl *cxx_ctor_decl(NULL);
4583 return NULL; // skip everything artificial
4587 cxx_dtor_decl = CXXDestructorDecl::Create (*m_ast,
4590 DeclarationNameInfo (m_ast->DeclarationNames.getCXXDestructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()),
4595 cxx_method_decl = cxx_dtor_decl;
4597 else if (decl_name == cxx_record_decl->getDeclName())
4599 cxx_ctor_decl = CXXConstructorDecl::Create (*m_ast,
4602 DeclarationNameInfo (m_ast->DeclarationNames.getCXXConstructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()),
4604 NULL, // TypeSourceInfo *
4608 false /*is_constexpr*/);
4609 cxx_method_decl = cxx_ctor_decl;
4613 clang::StorageClass SC = is_static ? SC_Static : SC_None;
4614 OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS;
4616 if (IsOperator (name, op_kind))
4618 if (op_kind != NUM_OVERLOADED_OPERATORS)
4620 // Check the number of operator parameters. Sometimes we have
4621 // seen bad DWARF that doesn't correctly describe operators and
4622 // if we try to create a methed and add it to the class, clang
4623 // will assert and crash, so we need to make sure things are
4625 if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params))
4627 cxx_method_decl = CXXMethodDecl::Create (*m_ast,
4630 DeclarationNameInfo (m_ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()),
4632 NULL, // TypeSourceInfo *
4635 false /*is_constexpr*/,
4638 else if (num_params == 0)
4640 // Conversion operators don't take params...
4641 cxx_method_decl = CXXConversionDecl::Create (*m_ast,
4644 DeclarationNameInfo (m_ast->DeclarationNames.getCXXConversionFunctionName (m_ast->getCanonicalType (function_type->getResultType())), SourceLocation()),
4646 NULL, // TypeSourceInfo *
4649 false /*is_constexpr*/,
4654 if (cxx_method_decl == NULL)
4656 cxx_method_decl = CXXMethodDecl::Create (*m_ast,
4659 DeclarationNameInfo (decl_name, SourceLocation()),
4661 NULL, // TypeSourceInfo *
4664 false /*is_constexpr*/,
4669 AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access);
4671 cxx_method_decl->setAccess (access_specifier);
4672 cxx_method_decl->setVirtualAsWritten (is_virtual);
4675 cxx_method_decl->addAttr(::new (*m_ast) UsedAttr(SourceRange(), *m_ast));
4677 // Populate the method decl with parameter decls
4679 llvm::SmallVector<ParmVarDecl *, 12> params;
4681 for (unsigned param_index = 0;
4682 param_index < num_params;
4685 params.push_back (ParmVarDecl::Create (*m_ast,
4690 method_function_prototype->getArgType(param_index),
4696 cxx_method_decl->setParams (ArrayRef<ParmVarDecl*>(params));
4698 cxx_record_decl->addDecl (cxx_method_decl);
4700 // Sometimes the debug info will mention a constructor (default/copy/move),
4701 // destructor, or assignment operator (copy/move) but there won't be any
4702 // version of this in the code. So we check if the function was artificially
4703 // generated and if it is trivial and this lets the compiler/backend know
4704 // that it can inline the IR for these when it needs to and we can avoid a
4705 // "missing function" error when running expressions.
4709 if (cxx_ctor_decl &&
4710 ((cxx_ctor_decl->isDefaultConstructor() && cxx_record_decl->hasTrivialDefaultConstructor ()) ||
4711 (cxx_ctor_decl->isCopyConstructor() && cxx_record_decl->hasTrivialCopyConstructor ()) ||
4712 (cxx_ctor_decl->isMoveConstructor() && cxx_record_decl->hasTrivialMoveConstructor ()) ))
4714 cxx_ctor_decl->setDefaulted();
4715 cxx_ctor_decl->setTrivial(true);
4717 else if (cxx_dtor_decl)
4719 if (cxx_record_decl->hasTrivialDestructor())
4721 cxx_dtor_decl->setDefaulted();
4722 cxx_dtor_decl->setTrivial(true);
4725 else if ((cxx_method_decl->isCopyAssignmentOperator() && cxx_record_decl->hasTrivialCopyAssignment()) ||
4726 (cxx_method_decl->isMoveAssignmentOperator() && cxx_record_decl->hasTrivialMoveAssignment()))
4728 cxx_method_decl->setDefaulted();
4729 cxx_method_decl->setTrivial(true);
4733 #ifdef LLDB_CONFIGURATION_DEBUG
4734 VerifyDecl(cxx_method_decl);
4737 // printf ("decl->isPolymorphic() = %i\n", cxx_record_decl->isPolymorphic());
4738 // printf ("decl->isAggregate() = %i\n", cxx_record_decl->isAggregate());
4739 // printf ("decl->isPOD() = %i\n", cxx_record_decl->isPOD());
4740 // printf ("decl->isEmpty() = %i\n", cxx_record_decl->isEmpty());
4741 // printf ("decl->isAbstract() = %i\n", cxx_record_decl->isAbstract());
4742 // printf ("decl->hasTrivialConstructor() = %i\n", cxx_record_decl->hasTrivialConstructor());
4743 // printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor());
4744 // printf ("decl->hasTrivialCopyAssignment() = %i\n", cxx_record_decl->hasTrivialCopyAssignment());
4745 // printf ("decl->hasTrivialDestructor() = %i\n", cxx_record_decl->hasTrivialDestructor());
4746 return cxx_method_decl;
4750 #pragma mark C++ Base Classes
4753 ClangASTType::CreateBaseClassSpecifier (AccessType access, bool is_virtual, bool base_of_class)
4756 return new CXXBaseSpecifier (SourceRange(),
4759 ClangASTContext::ConvertAccessTypeToAccessSpecifier (access),
4760 m_ast->getTrivialTypeSourceInfo (GetQualType()),
4766 ClangASTType::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes)
4768 for (unsigned i=0; i<num_base_classes; ++i)
4770 delete base_classes[i];
4771 base_classes[i] = NULL;
4776 ClangASTType::SetBaseClassesForClassType (CXXBaseSpecifier const * const *base_classes,
4777 unsigned num_base_classes)
4781 CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl();
4782 if (cxx_record_decl)
4784 cxx_record_decl->setBases(base_classes, num_base_classes);
4792 ClangASTType::SetObjCSuperClass (const ClangASTType &superclass_clang_type)
4794 if (IsValid() && superclass_clang_type.IsValid())
4796 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
4797 ObjCInterfaceDecl *super_interface_decl = superclass_clang_type.GetAsObjCInterfaceDecl ();
4798 if (class_interface_decl && super_interface_decl)
4800 class_interface_decl->setSuperClass(super_interface_decl);
4808 ClangASTType::AddObjCClassProperty (const char *property_name,
4809 const ClangASTType &property_clang_type,
4810 ObjCIvarDecl *ivar_decl,
4811 const char *property_setter_name,
4812 const char *property_getter_name,
4813 uint32_t property_attributes,
4814 ClangASTMetadata *metadata)
4816 if (!IsValid() || !property_clang_type.IsValid() || property_name == NULL || property_name[0] == '\0')
4819 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
4821 if (class_interface_decl)
4823 ClangASTType property_clang_type_to_access;
4825 if (property_clang_type.IsValid())
4826 property_clang_type_to_access = property_clang_type;
4828 property_clang_type_to_access = ClangASTType (m_ast, ivar_decl->getType());
4830 if (class_interface_decl && property_clang_type_to_access.IsValid())
4832 clang::TypeSourceInfo *prop_type_source;
4834 prop_type_source = m_ast->getTrivialTypeSourceInfo (ivar_decl->getType());
4836 prop_type_source = m_ast->getTrivialTypeSourceInfo (property_clang_type.GetQualType());
4838 ObjCPropertyDecl *property_decl = ObjCPropertyDecl::Create (*m_ast,
4839 class_interface_decl,
4840 SourceLocation(), // Source Location
4841 &m_ast->Idents.get(property_name),
4842 SourceLocation(), //Source Location for AT
4843 SourceLocation(), //Source location for (
4849 ClangASTContext::SetMetadata(m_ast, property_decl, *metadata);
4851 class_interface_decl->addDecl (property_decl);
4853 Selector setter_sel, getter_sel;
4855 if (property_setter_name != NULL)
4857 std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1);
4858 clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(property_setter_no_colon.c_str());
4859 setter_sel = m_ast->Selectors.getSelector(1, &setter_ident);
4861 else if (!(property_attributes & DW_APPLE_PROPERTY_readonly))
4863 std::string setter_sel_string("set");
4864 setter_sel_string.push_back(::toupper(property_name[0]));
4865 setter_sel_string.append(&property_name[1]);
4866 clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(setter_sel_string.c_str());
4867 setter_sel = m_ast->Selectors.getSelector(1, &setter_ident);
4869 property_decl->setSetterName(setter_sel);
4870 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter);
4872 if (property_getter_name != NULL)
4874 clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_getter_name);
4875 getter_sel = m_ast->Selectors.getSelector(0, &getter_ident);
4879 clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_name);
4880 getter_sel = m_ast->Selectors.getSelector(0, &getter_ident);
4882 property_decl->setGetterName(getter_sel);
4883 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_getter);
4886 property_decl->setPropertyIvarDecl (ivar_decl);
4888 if (property_attributes & DW_APPLE_PROPERTY_readonly)
4889 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readonly);
4890 if (property_attributes & DW_APPLE_PROPERTY_readwrite)
4891 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readwrite);
4892 if (property_attributes & DW_APPLE_PROPERTY_assign)
4893 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_assign);
4894 if (property_attributes & DW_APPLE_PROPERTY_retain)
4895 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_retain);
4896 if (property_attributes & DW_APPLE_PROPERTY_copy)
4897 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_copy);
4898 if (property_attributes & DW_APPLE_PROPERTY_nonatomic)
4899 property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_nonatomic);
4901 if (!getter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(getter_sel))
4903 const bool isInstance = true;
4904 const bool isVariadic = false;
4905 const bool isSynthesized = false;
4906 const bool isImplicitlyDeclared = true;
4907 const bool isDefined = false;
4908 const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None;
4909 const bool HasRelatedResultType = false;
4911 ObjCMethodDecl *getter = ObjCMethodDecl::Create (*m_ast,
4915 property_clang_type_to_access.GetQualType(),
4917 class_interface_decl,
4921 isImplicitlyDeclared,
4924 HasRelatedResultType);
4926 if (getter && metadata)
4927 ClangASTContext::SetMetadata(m_ast, getter, *metadata);
4929 getter->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(), ArrayRef<SourceLocation>());
4931 class_interface_decl->addDecl(getter);
4934 if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel))
4936 QualType result_type = m_ast->VoidTy;
4938 const bool isInstance = true;
4939 const bool isVariadic = false;
4940 const bool isSynthesized = false;
4941 const bool isImplicitlyDeclared = true;
4942 const bool isDefined = false;
4943 const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None;
4944 const bool HasRelatedResultType = false;
4946 ObjCMethodDecl *setter = ObjCMethodDecl::Create (*m_ast,
4952 class_interface_decl,
4956 isImplicitlyDeclared,
4959 HasRelatedResultType);
4961 if (setter && metadata)
4962 ClangASTContext::SetMetadata(m_ast, setter, *metadata);
4964 llvm::SmallVector<ParmVarDecl *, 1> params;
4966 params.push_back (ParmVarDecl::Create (*m_ast,
4971 property_clang_type_to_access.GetQualType(),
4976 setter->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>());
4978 class_interface_decl->addDecl(setter);
4989 ClangASTType::IsObjCClassTypeAndHasIVars (bool check_superclass) const
4991 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl ();
4992 if (class_interface_decl)
4993 return ObjCDeclHasIVars (class_interface_decl, check_superclass);
4999 ClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]")
5000 const ClangASTType &method_clang_type,
5001 lldb::AccessType access,
5004 if (!IsValid() || !method_clang_type.IsValid())
5007 ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl();
5009 if (class_interface_decl == NULL)
5012 const char *selector_start = ::strchr (name, ' ');
5013 if (selector_start == NULL)
5017 llvm::SmallVector<IdentifierInfo *, 12> selector_idents;
5021 //printf ("name = '%s'\n", name);
5023 unsigned num_selectors_with_args = 0;
5024 for (start = selector_start;
5025 start && *start != '\0' && *start != ']';
5028 len = ::strcspn(start, ":]");
5029 bool has_arg = (start[len] == ':');
5031 ++num_selectors_with_args;
5032 selector_idents.push_back (&m_ast->Idents.get (StringRef (start, len)));
5038 if (selector_idents.size() == 0)
5041 clang::Selector method_selector = m_ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
5042 selector_idents.data());
5044 QualType method_qual_type (method_clang_type.GetQualType());
5046 // Populate the method decl with parameter decls
5047 const clang::Type *method_type(method_qual_type.getTypePtr());
5049 if (method_type == NULL)
5052 const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type));
5054 if (!method_function_prototype)
5058 bool is_variadic = false;
5059 bool is_synthesized = false;
5060 bool is_defined = false;
5061 ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None;
5063 const unsigned num_args = method_function_prototype->getNumArgs();
5065 if (num_args != num_selectors_with_args)
5066 return NULL; // some debug information is corrupt. We are not going to deal with it.
5068 ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*m_ast,
5069 SourceLocation(), // beginLoc,
5070 SourceLocation(), // endLoc,
5072 method_function_prototype->getResultType(),
5073 NULL, // TypeSourceInfo *ResultTInfo,
5074 GetDeclContextForType (),
5078 true, // is_implicitly_declared; we force this to true because we don't have source locations
5081 false /*has_related_result_type*/);
5084 if (objc_method_decl == NULL)
5089 llvm::SmallVector<ParmVarDecl *, 12> params;
5091 for (unsigned param_index = 0; param_index < num_args; ++param_index)
5093 params.push_back (ParmVarDecl::Create (*m_ast,
5098 method_function_prototype->getArgType(param_index),
5104 objc_method_decl->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>());
5107 class_interface_decl->addDecl (objc_method_decl);
5109 #ifdef LLDB_CONFIGURATION_DEBUG
5110 VerifyDecl(objc_method_decl);
5113 return objc_method_decl;
5117 clang::DeclContext *
5118 ClangASTType::GetDeclContextForType () const
5123 QualType qual_type(GetCanonicalQualType());
5124 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5127 case clang::Type::UnaryTransform: break;
5128 case clang::Type::FunctionNoProto: break;
5129 case clang::Type::FunctionProto: break;
5130 case clang::Type::IncompleteArray: break;
5131 case clang::Type::VariableArray: break;
5132 case clang::Type::ConstantArray: break;
5133 case clang::Type::DependentSizedArray: break;
5134 case clang::Type::ExtVector: break;
5135 case clang::Type::DependentSizedExtVector: break;
5136 case clang::Type::Vector: break;
5137 case clang::Type::Builtin: break;
5138 case clang::Type::BlockPointer: break;
5139 case clang::Type::Pointer: break;
5140 case clang::Type::LValueReference: break;
5141 case clang::Type::RValueReference: break;
5142 case clang::Type::MemberPointer: break;
5143 case clang::Type::Complex: break;
5144 case clang::Type::ObjCObject: break;
5145 case clang::Type::ObjCInterface: return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface();
5146 case clang::Type::ObjCObjectPointer: return ClangASTType (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()).GetDeclContextForType();
5147 case clang::Type::Record: return cast<RecordType>(qual_type)->getDecl();
5148 case clang::Type::Enum: return cast<EnumType>(qual_type)->getDecl();
5149 case clang::Type::Typedef: return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDeclContextForType();
5150 case clang::Type::Elaborated: return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetDeclContextForType();
5151 case clang::Type::Paren: return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetDeclContextForType();
5152 case clang::Type::TypeOfExpr: break;
5153 case clang::Type::TypeOf: break;
5154 case clang::Type::Decltype: break;
5155 //case clang::Type::QualifiedName: break;
5156 case clang::Type::TemplateSpecialization: break;
5157 case clang::Type::DependentTemplateSpecialization: break;
5158 case clang::Type::TemplateTypeParm: break;
5159 case clang::Type::SubstTemplateTypeParm: break;
5160 case clang::Type::SubstTemplateTypeParmPack:break;
5161 case clang::Type::PackExpansion: break;
5162 case clang::Type::UnresolvedUsing: break;
5163 case clang::Type::Attributed: break;
5164 case clang::Type::Auto: break;
5165 case clang::Type::InjectedClassName: break;
5166 case clang::Type::DependentName: break;
5167 case clang::Type::Atomic: break;
5169 // No DeclContext in this type...
5174 ClangASTType::SetDefaultAccessForRecordFields (int default_accessibility,
5175 int *assigned_accessibilities,
5176 size_t num_assigned_accessibilities)
5180 RecordDecl *record_decl = GetAsRecordDecl();
5184 RecordDecl::field_iterator field, field_end;
5185 for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0;
5187 ++field, ++field_idx)
5189 // If no accessibility was assigned, assign the correct one
5190 if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none)
5191 field->setAccess ((AccessSpecifier)default_accessibility);
5201 ClangASTType::SetHasExternalStorage (bool has_extern)
5206 QualType qual_type (GetCanonicalQualType());
5208 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5211 case clang::Type::Record:
5213 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5214 if (cxx_record_decl)
5216 cxx_record_decl->setHasExternalLexicalStorage (has_extern);
5217 cxx_record_decl->setHasExternalVisibleStorage (has_extern);
5223 case clang::Type::Enum:
5225 EnumDecl *enum_decl = cast<EnumType>(qual_type)->getDecl();
5228 enum_decl->setHasExternalLexicalStorage (has_extern);
5229 enum_decl->setHasExternalVisibleStorage (has_extern);
5235 case clang::Type::ObjCObject:
5236 case clang::Type::ObjCInterface:
5238 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
5239 assert (objc_class_type);
5240 if (objc_class_type)
5242 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
5244 if (class_interface_decl)
5246 class_interface_decl->setHasExternalLexicalStorage (has_extern);
5247 class_interface_decl->setHasExternalVisibleStorage (has_extern);
5254 case clang::Type::Typedef:
5255 return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).SetHasExternalStorage (has_extern);
5257 case clang::Type::Elaborated:
5258 return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).SetHasExternalStorage (has_extern);
5260 case clang::Type::Paren:
5261 return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).SetHasExternalStorage (has_extern);
5270 ClangASTType::SetTagTypeKind (int kind) const
5274 QualType tag_qual_type(GetQualType());
5275 const clang::Type *clang_type = tag_qual_type.getTypePtr();
5278 const TagType *tag_type = dyn_cast<TagType>(clang_type);
5281 TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl());
5284 tag_decl->setTagKind ((TagDecl::TagKind)kind);
5294 #pragma mark TagDecl
5297 ClangASTType::StartTagDeclarationDefinition ()
5301 QualType qual_type (GetQualType());
5302 const clang::Type *t = qual_type.getTypePtr();
5305 const TagType *tag_type = dyn_cast<TagType>(t);
5308 TagDecl *tag_decl = tag_type->getDecl();
5311 tag_decl->startDefinition();
5316 const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(t);
5319 ObjCInterfaceDecl *interface_decl = object_type->getInterface();
5322 interface_decl->startDefinition();
5332 ClangASTType::CompleteTagDeclarationDefinition ()
5336 QualType qual_type (GetQualType());
5338 CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5340 if (cxx_record_decl)
5342 cxx_record_decl->completeDefinition();
5347 const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr());
5351 EnumDecl *enum_decl = enum_type->getDecl();
5355 /// TODO This really needs to be fixed.
5357 unsigned NumPositiveBits = 1;
5358 unsigned NumNegativeBits = 0;
5360 QualType promotion_qual_type;
5361 // If the enum integer type is less than an integer in bit width,
5362 // then we must promote it to an integer size.
5363 if (m_ast->getTypeSize(enum_decl->getIntegerType()) < m_ast->getTypeSize(m_ast->IntTy))
5365 if (enum_decl->getIntegerType()->isSignedIntegerType())
5366 promotion_qual_type = m_ast->IntTy;
5368 promotion_qual_type = m_ast->UnsignedIntTy;
5371 promotion_qual_type = enum_decl->getIntegerType();
5373 enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits);
5388 ClangASTType::AddEnumerationValueToEnumerationType (const ClangASTType &enumerator_clang_type,
5389 const Declaration &decl,
5392 uint32_t enum_value_bit_size)
5394 if (IsValid() && enumerator_clang_type.IsValid() && name && name[0])
5396 QualType enum_qual_type (GetCanonicalQualType());
5398 bool is_signed = false;
5399 enumerator_clang_type.IsIntegerType (is_signed);
5400 const clang::Type *clang_type = enum_qual_type.getTypePtr();
5403 const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
5407 llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed);
5408 enum_llvm_apsint = enum_value;
5409 EnumConstantDecl *enumerator_decl =
5410 EnumConstantDecl::Create (*m_ast,
5411 enum_type->getDecl(),
5413 name ? &m_ast->Idents.get(name) : NULL, // Identifier
5414 enumerator_clang_type.GetQualType(),
5418 if (enumerator_decl)
5420 enum_type->getDecl()->addDecl(enumerator_decl);
5422 #ifdef LLDB_CONFIGURATION_DEBUG
5423 VerifyDecl(enumerator_decl);
5436 ClangASTType::GetEnumerationIntegerType () const
5438 QualType enum_qual_type (GetCanonicalQualType());
5439 const clang::Type *clang_type = enum_qual_type.getTypePtr();
5442 const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
5445 EnumDecl *enum_decl = enum_type->getDecl();
5447 return ClangASTType (m_ast, enum_decl->getIntegerType());
5450 return ClangASTType();
5454 ClangASTType::CreateMemberPointerType (const ClangASTType &pointee_type) const
5456 if (IsValid() && pointee_type.IsValid())
5458 return ClangASTType (m_ast, m_ast->getMemberPointerType (pointee_type.GetQualType(),
5459 GetQualType().getTypePtr()));
5461 return ClangASTType();
5466 ClangASTType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst_size) const
5470 QualType qual_type (GetCanonicalQualType());
5472 bool is_complex = false;
5473 if (IsFloatingPointType (count, is_complex))
5475 // TODO: handle complex and vector types
5479 StringRef s_sref(s);
5480 APFloat ap_float(m_ast->getFloatTypeSemantics(qual_type), s_sref);
5482 const uint64_t bit_size = m_ast->getTypeSize (qual_type);
5483 const uint64_t byte_size = bit_size / 8;
5484 if (dst_size >= byte_size)
5486 if (bit_size == sizeof(float)*8)
5488 float float32 = ap_float.convertToFloat();
5489 ::memcpy (dst, &float32, byte_size);
5492 else if (bit_size >= 64)
5494 llvm::APInt ap_int(ap_float.bitcastToAPInt());
5495 ::memcpy (dst, ap_int.getRawData(), byte_size);
5506 //----------------------------------------------------------------------
5508 //----------------------------------------------------------------------
5509 #define DEPTH_INCREMENT 2
5512 ClangASTType::DumpValue (ExecutionContext *exe_ctx,
5514 lldb::Format format,
5515 const lldb_private::DataExtractor &data,
5516 lldb::offset_t data_byte_offset,
5517 size_t data_byte_size,
5518 uint32_t bitfield_bit_size,
5519 uint32_t bitfield_bit_offset,
5528 QualType qual_type(GetQualType());
5529 switch (qual_type->getTypeClass())
5531 case clang::Type::Record:
5532 if (GetCompleteType ())
5534 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
5535 const RecordDecl *record_decl = record_type->getDecl();
5536 assert(record_decl);
5537 uint32_t field_bit_offset = 0;
5538 uint32_t field_byte_offset = 0;
5539 const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl);
5540 uint32_t child_idx = 0;
5542 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
5543 if (cxx_record_decl)
5545 // We might have base classes to print out first
5546 CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
5547 for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
5548 base_class != base_class_end;
5551 const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
5553 // Skip empty base classes
5554 if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false)
5557 if (base_class->isVirtual())
5558 field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
5560 field_bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
5561 field_byte_offset = field_bit_offset / 8;
5562 assert (field_bit_offset % 8 == 0);
5568 QualType base_class_qual_type = base_class->getType();
5569 std::string base_class_type_name(base_class_qual_type.getAsString());
5571 // Indent and print the base class type name
5572 s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", base_class_type_name.c_str());
5574 std::pair<uint64_t, unsigned> base_class_type_info = m_ast->getTypeInfo(base_class_qual_type);
5576 // Dump the value of the member
5577 ClangASTType base_clang_type(m_ast, base_class_qual_type);
5578 base_clang_type.DumpValue (exe_ctx,
5579 s, // Stream to dump to
5580 base_clang_type.GetFormat(), // The format with which to display the member
5581 data, // Data buffer containing all bytes for this type
5582 data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from
5583 base_class_type_info.first / 8, // Size of this type in bytes
5584 0, // Bitfield bit size
5585 0, // Bitfield bit offset
5586 show_types, // Boolean indicating if we should show the variable types
5587 show_summary, // Boolean indicating if we should show a summary for the current type
5588 verbose, // Verbose output?
5589 depth + DEPTH_INCREMENT); // Scope depth for any types that have children
5594 uint32_t field_idx = 0;
5595 RecordDecl::field_iterator field, field_end;
5596 for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
5598 // Print the starting squiggly bracket (if this is the
5599 // first member) or comman (for member 2 and beyong) for
5600 // the struct/union/class member.
5607 s->Printf("\n%*s", depth + DEPTH_INCREMENT, "");
5609 QualType field_type = field->getType();
5610 // Print the member type if requested
5611 // Figure out the type byte size (field_type_info.first) and
5612 // alignment (field_type_info.second) from the AST context.
5613 std::pair<uint64_t, unsigned> field_type_info = m_ast->getTypeInfo(field_type);
5614 assert(field_idx < record_layout.getFieldCount());
5615 // Figure out the field offset within the current struct/union/class type
5616 field_bit_offset = record_layout.getFieldOffset (field_idx);
5617 field_byte_offset = field_bit_offset / 8;
5618 uint32_t field_bitfield_bit_size = 0;
5619 uint32_t field_bitfield_bit_offset = 0;
5620 if (ClangASTContext::FieldIsBitfield (m_ast, *field, field_bitfield_bit_size))
5621 field_bitfield_bit_offset = field_bit_offset % 8;
5625 std::string field_type_name(field_type.getAsString());
5626 if (field_bitfield_bit_size > 0)
5627 s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size);
5629 s->Printf("(%s) ", field_type_name.c_str());
5631 // Print the member name and equal sign
5632 s->Printf("%s = ", field->getNameAsString().c_str());
5635 // Dump the value of the member
5636 ClangASTType field_clang_type (m_ast, field_type);
5637 field_clang_type.DumpValue (exe_ctx,
5638 s, // Stream to dump to
5639 field_clang_type.GetFormat(), // The format with which to display the member
5640 data, // Data buffer containing all bytes for this type
5641 data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from
5642 field_type_info.first / 8, // Size of this type in bytes
5643 field_bitfield_bit_size, // Bitfield bit size
5644 field_bitfield_bit_offset, // Bitfield bit offset
5645 show_types, // Boolean indicating if we should show the variable types
5646 show_summary, // Boolean indicating if we should show a summary for the current type
5647 verbose, // Verbose output?
5648 depth + DEPTH_INCREMENT); // Scope depth for any types that have children
5651 // Indent the trailing squiggly bracket
5653 s->Printf("\n%*s}", depth, "");
5657 case clang::Type::Enum:
5658 if (GetCompleteType ())
5660 const EnumType *enum_type = cast<EnumType>(qual_type.getTypePtr());
5661 const EnumDecl *enum_decl = enum_type->getDecl();
5663 EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
5664 lldb::offset_t offset = data_byte_offset;
5665 const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset);
5666 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
5668 if (enum_pos->getInitVal() == enum_value)
5670 s->Printf("%s", enum_pos->getNameAsString().c_str());
5674 // If we have gotten here we didn't get find the enumerator in the
5675 // enum decl, so just print the integer.
5676 s->Printf("%" PRIi64, enum_value);
5680 case clang::Type::ConstantArray:
5682 const ConstantArrayType *array = cast<ConstantArrayType>(qual_type.getTypePtr());
5683 bool is_array_of_characters = false;
5684 QualType element_qual_type = array->getElementType();
5686 const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr();
5688 is_array_of_characters = canonical_type->isCharType();
5690 const uint64_t element_count = array->getSize().getLimitedValue();
5692 std::pair<uint64_t, unsigned> field_type_info = m_ast->getTypeInfo(element_qual_type);
5694 uint32_t element_idx = 0;
5695 uint32_t element_offset = 0;
5696 uint64_t element_byte_size = field_type_info.first / 8;
5697 uint32_t element_stride = element_byte_size;
5699 if (is_array_of_characters)
5702 data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
5708 ClangASTType element_clang_type(m_ast, element_qual_type);
5709 lldb::Format element_format = element_clang_type.GetFormat();
5711 for (element_idx = 0; element_idx < element_count; ++element_idx)
5713 // Print the starting squiggly bracket (if this is the
5714 // first member) or comman (for member 2 and beyong) for
5715 // the struct/union/class member.
5716 if (element_idx == 0)
5721 // Indent and print the index
5722 s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx);
5724 // Figure out the field offset within the current struct/union/class type
5725 element_offset = element_idx * element_stride;
5727 // Dump the value of the member
5728 element_clang_type.DumpValue (exe_ctx,
5729 s, // Stream to dump to
5730 element_format, // The format with which to display the element
5731 data, // Data buffer containing all bytes for this type
5732 data_byte_offset + element_offset,// Offset into "data" where to grab value from
5733 element_byte_size, // Size of this type in bytes
5734 0, // Bitfield bit size
5735 0, // Bitfield bit offset
5736 show_types, // Boolean indicating if we should show the variable types
5737 show_summary, // Boolean indicating if we should show a summary for the current type
5738 verbose, // Verbose output?
5739 depth + DEPTH_INCREMENT); // Scope depth for any types that have children
5742 // Indent the trailing squiggly bracket
5743 if (element_idx > 0)
5744 s->Printf("\n%*s}", depth, "");
5749 case clang::Type::Typedef:
5751 QualType typedef_qual_type = cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType();
5753 ClangASTType typedef_clang_type (m_ast, typedef_qual_type);
5754 lldb::Format typedef_format = typedef_clang_type.GetFormat();
5755 std::pair<uint64_t, unsigned> typedef_type_info = m_ast->getTypeInfo(typedef_qual_type);
5756 uint64_t typedef_byte_size = typedef_type_info.first / 8;
5758 return typedef_clang_type.DumpValue (exe_ctx,
5759 s, // Stream to dump to
5760 typedef_format, // The format with which to display the element
5761 data, // Data buffer containing all bytes for this type
5762 data_byte_offset, // Offset into "data" where to grab value from
5763 typedef_byte_size, // Size of this type in bytes
5764 bitfield_bit_size, // Bitfield bit size
5765 bitfield_bit_offset,// Bitfield bit offset
5766 show_types, // Boolean indicating if we should show the variable types
5767 show_summary, // Boolean indicating if we should show a summary for the current type
5768 verbose, // Verbose output?
5769 depth); // Scope depth for any types that have children
5773 case clang::Type::Elaborated:
5775 QualType elaborated_qual_type = cast<ElaboratedType>(qual_type)->getNamedType();
5776 ClangASTType elaborated_clang_type (m_ast, elaborated_qual_type);
5777 lldb::Format elaborated_format = elaborated_clang_type.GetFormat();
5778 std::pair<uint64_t, unsigned> elaborated_type_info = m_ast->getTypeInfo(elaborated_qual_type);
5779 uint64_t elaborated_byte_size = elaborated_type_info.first / 8;
5781 return elaborated_clang_type.DumpValue (exe_ctx,
5782 s, // Stream to dump to
5783 elaborated_format, // The format with which to display the element
5784 data, // Data buffer containing all bytes for this type
5785 data_byte_offset, // Offset into "data" where to grab value from
5786 elaborated_byte_size, // Size of this type in bytes
5787 bitfield_bit_size, // Bitfield bit size
5788 bitfield_bit_offset,// Bitfield bit offset
5789 show_types, // Boolean indicating if we should show the variable types
5790 show_summary, // Boolean indicating if we should show a summary for the current type
5791 verbose, // Verbose output?
5792 depth); // Scope depth for any types that have children
5796 case clang::Type::Paren:
5798 QualType desugar_qual_type = cast<ParenType>(qual_type)->desugar();
5799 ClangASTType desugar_clang_type (m_ast, desugar_qual_type);
5801 lldb::Format desugar_format = desugar_clang_type.GetFormat();
5802 std::pair<uint64_t, unsigned> desugar_type_info = m_ast->getTypeInfo(desugar_qual_type);
5803 uint64_t desugar_byte_size = desugar_type_info.first / 8;
5805 return desugar_clang_type.DumpValue (exe_ctx,
5806 s, // Stream to dump to
5807 desugar_format, // The format with which to display the element
5808 data, // Data buffer containing all bytes for this type
5809 data_byte_offset, // Offset into "data" where to grab value from
5810 desugar_byte_size, // Size of this type in bytes
5811 bitfield_bit_size, // Bitfield bit size
5812 bitfield_bit_offset,// Bitfield bit offset
5813 show_types, // Boolean indicating if we should show the variable types
5814 show_summary, // Boolean indicating if we should show a summary for the current type
5815 verbose, // Verbose output?
5816 depth); // Scope depth for any types that have children
5821 // We are down the a scalar type that we just need to display.
5828 LLDB_INVALID_ADDRESS,
5830 bitfield_bit_offset);
5833 DumpSummary (exe_ctx, s, data, data_byte_offset, data_byte_size);
5842 ClangASTType::DumpTypeValue (Stream *s,
5843 lldb::Format format,
5844 const lldb_private::DataExtractor &data,
5845 lldb::offset_t byte_offset,
5847 uint32_t bitfield_bit_size,
5848 uint32_t bitfield_bit_offset,
5849 ExecutionContextScope *exe_scope)
5853 if (IsAggregateType())
5859 QualType qual_type(GetQualType());
5861 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5864 case clang::Type::Typedef:
5866 QualType typedef_qual_type = cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType();
5867 ClangASTType typedef_clang_type (m_ast, typedef_qual_type);
5868 if (format == eFormatDefault)
5869 format = typedef_clang_type.GetFormat();
5870 std::pair<uint64_t, unsigned> typedef_type_info = m_ast->getTypeInfo(typedef_qual_type);
5871 uint64_t typedef_byte_size = typedef_type_info.first / 8;
5873 return typedef_clang_type.DumpTypeValue (s,
5874 format, // The format with which to display the element
5875 data, // Data buffer containing all bytes for this type
5876 byte_offset, // Offset into "data" where to grab value from
5877 typedef_byte_size, // Size of this type in bytes
5878 bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield
5879 bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_size != 0
5884 case clang::Type::Enum:
5885 // If our format is enum or default, show the enumeration value as
5886 // its enumeration string value, else just display it as requested.
5887 if ((format == eFormatEnum || format == eFormatDefault) && GetCompleteType ())
5889 const EnumType *enum_type = cast<EnumType>(qual_type.getTypePtr());
5890 const EnumDecl *enum_decl = enum_type->getDecl();
5892 EnumDecl::enumerator_iterator enum_pos, enum_end_pos;
5893 const bool is_signed = qual_type->isSignedIntegerOrEnumerationType();
5894 lldb::offset_t offset = byte_offset;
5897 const int64_t enum_svalue = data.GetMaxS64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
5898 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
5900 if (enum_pos->getInitVal().getSExtValue() == enum_svalue)
5902 s->PutCString (enum_pos->getNameAsString().c_str());
5906 // If we have gotten here we didn't get find the enumerator in the
5907 // enum decl, so just print the integer.
5908 s->Printf("%" PRIi64, enum_svalue);
5912 const uint64_t enum_uvalue = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
5913 for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos)
5915 if (enum_pos->getInitVal().getZExtValue() == enum_uvalue)
5917 s->PutCString (enum_pos->getNameAsString().c_str());
5921 // If we have gotten here we didn't get find the enumerator in the
5922 // enum decl, so just print the integer.
5923 s->Printf("%" PRIu64, enum_uvalue);
5927 // format was not enum, just fall through and dump the value as requested....
5930 // We are down the a scalar type that we just need to display.
5932 uint32_t item_count = 1;
5933 // A few formats, we might need to modify our size and count for depending
5934 // on how we are trying to display the value...
5938 case eFormatBoolean:
5940 case eFormatComplex:
5941 case eFormatCString: // NULL terminated C strings
5942 case eFormatDecimal:
5945 case eFormatHexUppercase:
5949 case eFormatUnsigned:
5950 case eFormatPointer:
5951 case eFormatVectorOfChar:
5952 case eFormatVectorOfSInt8:
5953 case eFormatVectorOfUInt8:
5954 case eFormatVectorOfSInt16:
5955 case eFormatVectorOfUInt16:
5956 case eFormatVectorOfSInt32:
5957 case eFormatVectorOfUInt32:
5958 case eFormatVectorOfSInt64:
5959 case eFormatVectorOfUInt64:
5960 case eFormatVectorOfFloat32:
5961 case eFormatVectorOfFloat64:
5962 case eFormatVectorOfUInt128:
5966 case eFormatCharPrintable:
5967 case eFormatCharArray:
5969 case eFormatBytesWithASCII:
5970 item_count = byte_size;
5974 case eFormatUnicode16:
5975 item_count = byte_size / 2;
5979 case eFormatUnicode32:
5980 item_count = byte_size / 4;
5984 return data.Dump (s,
5990 LLDB_INVALID_ADDRESS,
5992 bitfield_bit_offset,
6004 ClangASTType::DumpSummary (ExecutionContext *exe_ctx,
6006 const lldb_private::DataExtractor &data,
6007 lldb::offset_t data_byte_offset,
6008 size_t data_byte_size)
6010 uint32_t length = 0;
6011 if (IsCStringType (length))
6015 Process *process = exe_ctx->GetProcessPtr();
6018 lldb::offset_t offset = data_byte_offset;
6019 lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size);
6020 std::vector<uint8_t> buf;
6022 buf.resize (length);
6026 lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), process->GetByteOrder(), 4);
6029 size_t total_cstr_len = 0;
6031 while ((bytes_read = process->ReadMemory (pointer_addresss, &buf.front(), buf.size(), error)) > 0)
6033 const size_t len = strlen((const char *)&buf.front());
6036 if (total_cstr_len == 0)
6037 s->PutCString (" \"");
6038 cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
6039 total_cstr_len += len;
6040 if (len < buf.size())
6042 pointer_addresss += total_cstr_len;
6044 if (total_cstr_len > 0)
6052 ClangASTType::DumpTypeDescription () const
6054 StreamFile s (stdout, false);
6055 DumpTypeDescription (&s);
6056 ClangASTMetadata *metadata = ClangASTContext::GetMetadata (m_ast, m_type);
6059 metadata->Dump (&s);
6064 ClangASTType::DumpTypeDescription (Stream *s) const
6068 QualType qual_type(GetQualType());
6070 SmallVector<char, 1024> buf;
6071 raw_svector_ostream llvm_ostrm (buf);
6073 const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6076 case clang::Type::ObjCObject:
6077 case clang::Type::ObjCInterface:
6081 const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
6082 assert (objc_class_type);
6083 if (objc_class_type)
6085 ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
6086 if (class_interface_decl)
6088 PrintingPolicy policy = m_ast->getPrintingPolicy();
6089 class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel());
6095 case clang::Type::Typedef:
6097 const TypedefType *typedef_type = qual_type->getAs<TypedefType>();
6100 const TypedefNameDecl *typedef_decl = typedef_type->getDecl();
6101 std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString());
6102 if (!clang_typedef_name.empty())
6104 s->PutCString ("typedef ");
6105 s->PutCString (clang_typedef_name.c_str());
6111 case clang::Type::Elaborated:
6112 ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).DumpTypeDescription(s);
6115 case clang::Type::Paren:
6116 ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).DumpTypeDescription(s);
6119 case clang::Type::Record:
6123 const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
6124 const RecordDecl *record_decl = record_type->getDecl();
6125 const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
6127 if (cxx_record_decl)
6128 cxx_record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel());
6130 record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel());
6136 const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr());
6139 TagDecl *tag_decl = tag_type->getDecl();
6141 tag_decl->print(llvm_ostrm, 0);
6145 std::string clang_type_name(qual_type.getAsString());
6146 if (!clang_type_name.empty())
6147 s->PutCString (clang_type_name.c_str());
6155 s->Write (buf.data(), buf.size());
6161 ClangASTType::GetValueAsScalar (const lldb_private::DataExtractor &data,
6162 lldb::offset_t data_byte_offset,
6163 size_t data_byte_size,
6164 Scalar &value) const
6169 if (IsAggregateType ())
6171 return false; // Aggregate types don't have scalar values
6176 lldb::Encoding encoding = GetEncoding (count);
6178 if (encoding == lldb::eEncodingInvalid || count != 1)
6181 const uint64_t byte_size = GetByteSize();
6182 lldb::offset_t offset = data_byte_offset;
6185 case lldb::eEncodingInvalid:
6187 case lldb::eEncodingVector:
6189 case lldb::eEncodingUint:
6190 if (byte_size <= sizeof(unsigned long long))
6192 uint64_t uval64 = data.GetMaxU64 (&offset, byte_size);
6193 if (byte_size <= sizeof(unsigned int))
6195 value = (unsigned int)uval64;
6198 else if (byte_size <= sizeof(unsigned long))
6200 value = (unsigned long)uval64;
6203 else if (byte_size <= sizeof(unsigned long long))
6205 value = (unsigned long long )uval64;
6213 case lldb::eEncodingSint:
6214 if (byte_size <= sizeof(long long))
6216 int64_t sval64 = data.GetMaxS64 (&offset, byte_size);
6217 if (byte_size <= sizeof(int))
6219 value = (int)sval64;
6222 else if (byte_size <= sizeof(long))
6224 value = (long)sval64;
6227 else if (byte_size <= sizeof(long long))
6229 value = (long long )sval64;
6237 case lldb::eEncodingIEEE754:
6238 if (byte_size <= sizeof(long double))
6242 if (byte_size == sizeof(float))
6244 if (sizeof(float) == sizeof(uint32_t))
6246 u32 = data.GetU32(&offset);
6247 value = *((float *)&u32);
6250 else if (sizeof(float) == sizeof(uint64_t))
6252 u64 = data.GetU64(&offset);
6253 value = *((float *)&u64);
6258 if (byte_size == sizeof(double))
6260 if (sizeof(double) == sizeof(uint32_t))
6262 u32 = data.GetU32(&offset);
6263 value = *((double *)&u32);
6266 else if (sizeof(double) == sizeof(uint64_t))
6268 u64 = data.GetU64(&offset);
6269 value = *((double *)&u64);
6274 if (byte_size == sizeof(long double))
6276 if (sizeof(long double) == sizeof(uint32_t))
6278 u32 = data.GetU32(&offset);
6279 value = *((long double *)&u32);
6282 else if (sizeof(long double) == sizeof(uint64_t))
6284 u64 = data.GetU64(&offset);
6285 value = *((long double *)&u64);
6297 ClangASTType::SetValueFromScalar (const Scalar &value, Stream &strm)
6299 // Aggregate types don't have scalar values
6300 if (!IsAggregateType ())
6302 strm.GetFlags().Set(Stream::eBinary);
6304 lldb::Encoding encoding = GetEncoding (count);
6306 if (encoding == lldb::eEncodingInvalid || count != 1)
6309 const uint64_t bit_width = GetBitSize();
6310 // This function doesn't currently handle non-byte aligned assignments
6311 if ((bit_width % 8) != 0)
6314 const uint64_t byte_size = (bit_width + 7 ) / 8;
6317 case lldb::eEncodingInvalid:
6319 case lldb::eEncodingVector:
6321 case lldb::eEncodingUint:
6324 case 1: strm.PutHex8(value.UInt()); return true;
6325 case 2: strm.PutHex16(value.UInt()); return true;
6326 case 4: strm.PutHex32(value.UInt()); return true;
6327 case 8: strm.PutHex64(value.ULongLong()); return true;
6333 case lldb::eEncodingSint:
6336 case 1: strm.PutHex8(value.SInt()); return true;
6337 case 2: strm.PutHex16(value.SInt()); return true;
6338 case 4: strm.PutHex32(value.SInt()); return true;
6339 case 8: strm.PutHex64(value.SLongLong()); return true;
6345 case lldb::eEncodingIEEE754:
6346 if (byte_size <= sizeof(long double))
6348 if (byte_size == sizeof(float))
6350 strm.PutFloat(value.Float());
6354 if (byte_size == sizeof(double))
6356 strm.PutDouble(value.Double());
6360 if (byte_size == sizeof(long double))
6362 strm.PutDouble(value.LongDouble());
6373 ClangASTType::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx,
6375 AddressType address_type,
6376 lldb_private::DataExtractor &data)
6381 // Can't convert a file address to anything valid without more
6382 // context (which Module it came from)
6383 if (address_type == eAddressTypeFile)
6386 if (!GetCompleteType())
6389 const uint64_t byte_size = GetByteSize();
6390 if (data.GetByteSize() < byte_size)
6392 lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0'));
6393 data.SetData(data_sp);
6396 uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size);
6399 if (address_type == eAddressTypeHost)
6403 // The address is an address in this process, so just copy it
6404 memcpy (dst, (uint8_t*)NULL + addr, byte_size);
6409 Process *process = NULL;
6411 process = exe_ctx->GetProcessPtr();
6415 return process->ReadMemory(addr, dst, byte_size, error) == byte_size;
6423 ClangASTType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx,
6425 AddressType address_type,
6426 StreamString &new_value)
6431 // Can't convert a file address to anything valid without more
6432 // context (which Module it came from)
6433 if (address_type == eAddressTypeFile)
6436 if (!GetCompleteType())
6439 const uint64_t byte_size = GetByteSize();
6443 if (address_type == eAddressTypeHost)
6445 // The address is an address in this process, so just copy it
6446 memcpy ((void *)addr, new_value.GetData(), byte_size);
6451 Process *process = NULL;
6453 process = exe_ctx->GetProcessPtr();
6457 return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size;
6466 //ClangASTType::GetAsCXXRecordDecl (lldb::clang_type_t opaque_clang_qual_type)
6468 // if (opaque_clang_qual_type)
6469 // return QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl();
6474 lldb_private::operator == (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs)
6476 return lhs.GetASTContext() == rhs.GetASTContext() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType();
6481 lldb_private::operator != (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs)
6483 return lhs.GetASTContext() != rhs.GetASTContext() || lhs.GetOpaqueQualType() != rhs.GetOpaqueQualType();