1254721Semaste//===-- ClangASTType.cpp ----------------------------------------*- C++ -*-===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste 10254721Semaste#include "lldb/lldb-python.h" 11254721Semaste 12254721Semaste#include "lldb/Symbol/ClangASTType.h" 13254721Semaste 14254721Semaste#include "clang/AST/ASTConsumer.h" 15254721Semaste#include "clang/AST/ASTContext.h" 16254721Semaste#include "clang/AST/Attr.h" 17254721Semaste#include "clang/AST/CXXInheritance.h" 18254721Semaste#include "clang/AST/Decl.h" 19254721Semaste#include "clang/AST/DeclCXX.h" 20254721Semaste#include "clang/AST/DeclObjC.h" 21254721Semaste#include "clang/AST/DeclGroup.h" 22254721Semaste#include "clang/AST/DeclTemplate.h" 23254721Semaste#include "clang/AST/RecordLayout.h" 24254721Semaste#include "clang/AST/Type.h" 25254721Semaste 26254721Semaste#include "clang/Basic/Builtins.h" 27254721Semaste#include "clang/Basic/IdentifierTable.h" 28254721Semaste#include "clang/Basic/LangOptions.h" 29254721Semaste#include "clang/Basic/SourceManager.h" 30254721Semaste#include "clang/Basic/TargetInfo.h" 31254721Semaste 32254721Semaste#include "llvm/Support/FormattedStream.h" 33254721Semaste#include "llvm/Support/raw_ostream.h" 34254721Semaste 35254721Semaste#include "lldb/Core/ConstString.h" 36254721Semaste#include "lldb/Core/DataBufferHeap.h" 37254721Semaste#include "lldb/Core/DataExtractor.h" 38254721Semaste#include "lldb/Core/Debugger.h" 39254721Semaste#include "lldb/Core/Scalar.h" 40254721Semaste#include "lldb/Core/Stream.h" 41269024Semaste#include "lldb/Core/StreamFile.h" 42254721Semaste#include "lldb/Core/StreamString.h" 43254721Semaste#include "lldb/Symbol/ClangASTContext.h" 44254721Semaste#include "lldb/Symbol/ClangExternalASTSourceCommon.h" 45254721Semaste#include "lldb/Symbol/VerifyDecl.h" 46254721Semaste#include "lldb/Target/ExecutionContext.h" 47254721Semaste#include "lldb/Target/Process.h" 48254721Semaste 49254721Semaste#include <mutex> 50254721Semaste 51254721Semasteusing namespace lldb; 52254721Semasteusing namespace lldb_private; 53254721Semasteusing namespace clang; 54254721Semasteusing namespace llvm; 55254721Semaste 56254721Semastestatic bool 57254721SemasteGetCompleteQualType (ASTContext *ast, QualType qual_type, bool allow_completion = true) 58254721Semaste{ 59254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 60254721Semaste switch (type_class) 61254721Semaste { 62254721Semaste case clang::Type::ConstantArray: 63254721Semaste case clang::Type::IncompleteArray: 64254721Semaste case clang::Type::VariableArray: 65254721Semaste { 66254721Semaste const ArrayType *array_type = dyn_cast<ArrayType>(qual_type.getTypePtr()); 67254721Semaste 68254721Semaste if (array_type) 69254721Semaste return GetCompleteQualType (ast, array_type->getElementType(), allow_completion); 70254721Semaste } 71254721Semaste break; 72254721Semaste 73254721Semaste case clang::Type::Record: 74254721Semaste case clang::Type::Enum: 75254721Semaste { 76254721Semaste const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr()); 77254721Semaste if (tag_type) 78254721Semaste { 79254721Semaste TagDecl *tag_decl = tag_type->getDecl(); 80254721Semaste if (tag_decl) 81254721Semaste { 82254721Semaste if (tag_decl->isCompleteDefinition()) 83254721Semaste return true; 84254721Semaste 85254721Semaste if (!allow_completion) 86254721Semaste return false; 87254721Semaste 88254721Semaste if (tag_decl->hasExternalLexicalStorage()) 89254721Semaste { 90254721Semaste if (ast) 91254721Semaste { 92254721Semaste ExternalASTSource *external_ast_source = ast->getExternalSource(); 93254721Semaste if (external_ast_source) 94254721Semaste { 95254721Semaste external_ast_source->CompleteType(tag_decl); 96254721Semaste return !tag_type->isIncompleteType(); 97254721Semaste } 98254721Semaste } 99254721Semaste } 100254721Semaste return false; 101254721Semaste } 102254721Semaste } 103254721Semaste 104254721Semaste } 105254721Semaste break; 106254721Semaste 107254721Semaste case clang::Type::ObjCObject: 108254721Semaste case clang::Type::ObjCInterface: 109254721Semaste { 110254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type); 111254721Semaste if (objc_class_type) 112254721Semaste { 113254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 114254721Semaste // We currently can't complete objective C types through the newly added ASTContext 115254721Semaste // because it only supports TagDecl objects right now... 116254721Semaste if (class_interface_decl) 117254721Semaste { 118254721Semaste if (class_interface_decl->getDefinition()) 119254721Semaste return true; 120254721Semaste 121254721Semaste if (!allow_completion) 122254721Semaste return false; 123254721Semaste 124254721Semaste if (class_interface_decl->hasExternalLexicalStorage()) 125254721Semaste { 126254721Semaste if (ast) 127254721Semaste { 128254721Semaste ExternalASTSource *external_ast_source = ast->getExternalSource(); 129254721Semaste if (external_ast_source) 130254721Semaste { 131254721Semaste external_ast_source->CompleteType (class_interface_decl); 132254721Semaste return !objc_class_type->isIncompleteType(); 133254721Semaste } 134254721Semaste } 135254721Semaste } 136254721Semaste return false; 137254721Semaste } 138254721Semaste } 139254721Semaste } 140254721Semaste break; 141254721Semaste 142254721Semaste case clang::Type::Typedef: 143254721Semaste return GetCompleteQualType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion); 144254721Semaste 145254721Semaste case clang::Type::Elaborated: 146254721Semaste return GetCompleteQualType (ast, cast<ElaboratedType>(qual_type)->getNamedType(), allow_completion); 147254721Semaste 148254721Semaste case clang::Type::Paren: 149254721Semaste return GetCompleteQualType (ast, cast<ParenType>(qual_type)->desugar(), allow_completion); 150254721Semaste 151254721Semaste default: 152254721Semaste break; 153254721Semaste } 154254721Semaste 155254721Semaste return true; 156254721Semaste} 157254721Semaste 158254721Semastestatic ObjCIvarDecl::AccessControl 159254721SemasteConvertAccessTypeToObjCIvarAccessControl (AccessType access) 160254721Semaste{ 161254721Semaste switch (access) 162254721Semaste { 163254721Semaste case eAccessNone: return ObjCIvarDecl::None; 164254721Semaste case eAccessPublic: return ObjCIvarDecl::Public; 165254721Semaste case eAccessPrivate: return ObjCIvarDecl::Private; 166254721Semaste case eAccessProtected: return ObjCIvarDecl::Protected; 167254721Semaste case eAccessPackage: return ObjCIvarDecl::Package; 168254721Semaste } 169254721Semaste return ObjCIvarDecl::None; 170254721Semaste} 171254721Semaste 172254721Semaste//---------------------------------------------------------------------- 173254721Semaste// Tests 174254721Semaste//---------------------------------------------------------------------- 175254721Semaste 176254721SemasteClangASTType::ClangASTType (clang::ASTContext *ast, 177254721Semaste clang::QualType qual_type) : 178254721Semaste m_type (qual_type.getAsOpaquePtr()), 179254721Semaste m_ast (ast) 180254721Semaste{ 181254721Semaste} 182254721Semaste 183254721SemasteClangASTType::~ClangASTType() 184254721Semaste{ 185254721Semaste} 186254721Semaste 187254721Semaste//---------------------------------------------------------------------- 188254721Semaste// Tests 189254721Semaste//---------------------------------------------------------------------- 190254721Semaste 191254721Semastebool 192254721SemasteClangASTType::IsAggregateType () const 193254721Semaste{ 194254721Semaste if (!IsValid()) 195254721Semaste return false; 196254721Semaste 197254721Semaste QualType qual_type (GetCanonicalQualType()); 198254721Semaste 199254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 200254721Semaste switch (type_class) 201254721Semaste { 202254721Semaste case clang::Type::IncompleteArray: 203254721Semaste case clang::Type::VariableArray: 204254721Semaste case clang::Type::ConstantArray: 205254721Semaste case clang::Type::ExtVector: 206254721Semaste case clang::Type::Vector: 207254721Semaste case clang::Type::Record: 208254721Semaste case clang::Type::ObjCObject: 209254721Semaste case clang::Type::ObjCInterface: 210254721Semaste return true; 211254721Semaste case clang::Type::Elaborated: 212254721Semaste return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsAggregateType(); 213254721Semaste case clang::Type::Typedef: 214254721Semaste return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsAggregateType(); 215254721Semaste case clang::Type::Paren: 216254721Semaste return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).IsAggregateType(); 217254721Semaste default: 218254721Semaste break; 219254721Semaste } 220254721Semaste // The clang type does have a value 221254721Semaste return false; 222254721Semaste} 223254721Semaste 224254721Semastebool 225254721SemasteClangASTType::IsArrayType (ClangASTType *element_type_ptr, 226254721Semaste uint64_t *size, 227254721Semaste bool *is_incomplete) const 228254721Semaste{ 229254721Semaste if (IsValid()) 230254721Semaste { 231254721Semaste QualType qual_type (GetCanonicalQualType()); 232254721Semaste 233254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 234254721Semaste switch (type_class) 235254721Semaste { 236254721Semaste default: 237254721Semaste break; 238254721Semaste 239254721Semaste case clang::Type::ConstantArray: 240254721Semaste if (element_type_ptr) 241254721Semaste element_type_ptr->SetClangType (m_ast, cast<ConstantArrayType>(qual_type)->getElementType()); 242254721Semaste if (size) 243254721Semaste *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX); 244254721Semaste return true; 245254721Semaste 246254721Semaste case clang::Type::IncompleteArray: 247254721Semaste if (element_type_ptr) 248254721Semaste element_type_ptr->SetClangType (m_ast, cast<IncompleteArrayType>(qual_type)->getElementType()); 249254721Semaste if (size) 250254721Semaste *size = 0; 251254721Semaste if (is_incomplete) 252254721Semaste *is_incomplete = true; 253254721Semaste return true; 254254721Semaste 255254721Semaste case clang::Type::VariableArray: 256254721Semaste if (element_type_ptr) 257254721Semaste element_type_ptr->SetClangType (m_ast, cast<VariableArrayType>(qual_type)->getElementType()); 258254721Semaste if (size) 259254721Semaste *size = 0; 260254721Semaste return true; 261254721Semaste 262254721Semaste case clang::Type::DependentSizedArray: 263254721Semaste if (element_type_ptr) 264254721Semaste element_type_ptr->SetClangType (m_ast, cast<DependentSizedArrayType>(qual_type)->getElementType()); 265254721Semaste if (size) 266254721Semaste *size = 0; 267254721Semaste return true; 268254721Semaste 269254721Semaste case clang::Type::Typedef: 270254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsArrayType (element_type_ptr, 271254721Semaste size, 272254721Semaste is_incomplete); 273254721Semaste case clang::Type::Elaborated: 274254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsArrayType (element_type_ptr, 275254721Semaste size, 276254721Semaste is_incomplete); 277254721Semaste case clang::Type::Paren: 278254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsArrayType (element_type_ptr, 279254721Semaste size, 280254721Semaste is_incomplete); 281254721Semaste } 282254721Semaste } 283254721Semaste if (element_type_ptr) 284254721Semaste element_type_ptr->Clear(); 285254721Semaste if (size) 286254721Semaste *size = 0; 287254721Semaste if (is_incomplete) 288254721Semaste *is_incomplete = false; 289254721Semaste return 0; 290254721Semaste} 291254721Semaste 292263363Semastebool 293263363SemasteClangASTType::IsRuntimeGeneratedType () const 294263363Semaste{ 295263363Semaste if (!IsValid()) 296263363Semaste return false; 297263363Semaste 298263363Semaste clang::DeclContext* decl_ctx = GetDeclContextForType(); 299263363Semaste if (!decl_ctx) 300263363Semaste return false; 301254721Semaste 302263363Semaste if (!llvm::isa<clang::ObjCInterfaceDecl>(decl_ctx)) 303263363Semaste return false; 304263363Semaste 305263363Semaste clang::ObjCInterfaceDecl *result_iface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl_ctx); 306263363Semaste 307263363Semaste ClangASTMetadata* ast_metadata = ClangASTContext::GetMetadata(m_ast, result_iface_decl); 308263363Semaste if (!ast_metadata) 309263363Semaste return false; 310263363Semaste return (ast_metadata->GetISAPtr() != 0); 311263363Semaste} 312263363Semaste 313254721Semastebool 314254721SemasteClangASTType::IsCharType () const 315254721Semaste{ 316254721Semaste if (!IsValid()) 317254721Semaste return false; 318254721Semaste return GetQualType().getUnqualifiedType()->isCharType(); 319254721Semaste} 320254721Semaste 321254721Semaste 322254721Semastebool 323254721SemasteClangASTType::IsCompleteType () const 324254721Semaste{ 325254721Semaste if (!IsValid()) 326254721Semaste return false; 327254721Semaste const bool allow_completion = false; 328254721Semaste return GetCompleteQualType (m_ast, GetQualType(), allow_completion); 329254721Semaste} 330254721Semaste 331254721Semastebool 332254721SemasteClangASTType::IsConst() const 333254721Semaste{ 334254721Semaste return GetQualType().isConstQualified(); 335254721Semaste} 336254721Semaste 337254721Semastebool 338254721SemasteClangASTType::IsCStringType (uint32_t &length) const 339254721Semaste{ 340254721Semaste ClangASTType pointee_or_element_clang_type; 341254721Semaste length = 0; 342254721Semaste Flags type_flags (GetTypeInfo (&pointee_or_element_clang_type)); 343254721Semaste 344254721Semaste if (!pointee_or_element_clang_type.IsValid()) 345254721Semaste return false; 346254721Semaste 347254721Semaste if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer)) 348254721Semaste { 349254721Semaste if (pointee_or_element_clang_type.IsCharType()) 350254721Semaste { 351254721Semaste if (type_flags.Test (eTypeIsArray)) 352254721Semaste { 353254721Semaste // We know the size of the array and it could be a C string 354254721Semaste // since it is an array of characters 355254721Semaste length = cast<ConstantArrayType>(GetCanonicalQualType().getTypePtr())->getSize().getLimitedValue(); 356254721Semaste } 357254721Semaste return true; 358254721Semaste 359254721Semaste } 360254721Semaste } 361254721Semaste return false; 362254721Semaste} 363254721Semaste 364254721Semastebool 365254721SemasteClangASTType::IsFunctionType (bool *is_variadic_ptr) const 366254721Semaste{ 367254721Semaste if (IsValid()) 368254721Semaste { 369254721Semaste QualType qual_type (GetCanonicalQualType()); 370254721Semaste 371254721Semaste if (qual_type->isFunctionType()) 372254721Semaste { 373254721Semaste if (is_variadic_ptr) 374254721Semaste { 375254721Semaste const clang::FunctionProtoType *function_proto_type = llvm::dyn_cast<clang::FunctionProtoType>(qual_type.getTypePtr()); 376254721Semaste if (function_proto_type) 377254721Semaste *is_variadic_ptr = function_proto_type->isVariadic(); 378254721Semaste else 379254721Semaste *is_variadic_ptr = false; 380254721Semaste } 381254721Semaste return true; 382254721Semaste } 383254721Semaste 384254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 385254721Semaste switch (type_class) 386254721Semaste { 387254721Semaste default: 388254721Semaste break; 389254721Semaste case clang::Type::Typedef: 390254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionType(); 391254721Semaste case clang::Type::Elaborated: 392254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsFunctionType(); 393254721Semaste case clang::Type::Paren: 394254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsFunctionType(); 395254721Semaste 396254721Semaste case clang::Type::LValueReference: 397254721Semaste case clang::Type::RValueReference: 398254721Semaste { 399254721Semaste const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 400254721Semaste if (reference_type) 401254721Semaste return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionType(); 402254721Semaste } 403254721Semaste break; 404254721Semaste } 405254721Semaste } 406254721Semaste return false; 407254721Semaste} 408254721Semaste 409263363Semastesize_t 410263363SemasteClangASTType::GetNumberOfFunctionArguments () const 411263363Semaste{ 412263363Semaste if (IsValid()) 413263363Semaste { 414263363Semaste QualType qual_type (GetCanonicalQualType()); 415263363Semaste const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr()); 416263363Semaste if (func) 417263363Semaste return func->getNumArgs(); 418263363Semaste } 419263363Semaste return 0; 420263363Semaste} 421254721Semaste 422263363SemasteClangASTType 423263363SemasteClangASTType::GetFunctionArgumentAtIndex (const size_t index) 424263363Semaste{ 425263363Semaste if (IsValid()) 426263363Semaste { 427263363Semaste QualType qual_type (GetCanonicalQualType()); 428263363Semaste const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr()); 429263363Semaste if (func) 430263363Semaste { 431263363Semaste if (index < func->getNumArgs()) 432263363Semaste return ClangASTType(m_ast, func->getArgType(index).getAsOpaquePtr()); 433263363Semaste } 434263363Semaste } 435263363Semaste return ClangASTType(); 436263363Semaste} 437263363Semaste 438254721Semastebool 439254721SemasteClangASTType::IsFunctionPointerType () const 440254721Semaste{ 441254721Semaste if (IsValid()) 442254721Semaste { 443254721Semaste QualType qual_type (GetCanonicalQualType()); 444254721Semaste 445254721Semaste if (qual_type->isFunctionPointerType()) 446254721Semaste return true; 447254721Semaste 448254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 449254721Semaste switch (type_class) 450254721Semaste { 451254721Semaste default: 452254721Semaste break; 453254721Semaste case clang::Type::Typedef: 454254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsFunctionPointerType(); 455254721Semaste case clang::Type::Elaborated: 456254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsFunctionPointerType(); 457254721Semaste case clang::Type::Paren: 458254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsFunctionPointerType(); 459254721Semaste 460254721Semaste case clang::Type::LValueReference: 461254721Semaste case clang::Type::RValueReference: 462254721Semaste { 463254721Semaste const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 464254721Semaste if (reference_type) 465254721Semaste return ClangASTType (m_ast, reference_type->getPointeeType()).IsFunctionPointerType(); 466254721Semaste } 467254721Semaste break; 468254721Semaste } 469254721Semaste } 470254721Semaste return false; 471254721Semaste 472254721Semaste} 473254721Semaste 474254721Semastebool 475254721SemasteClangASTType::IsIntegerType (bool &is_signed) const 476254721Semaste{ 477254721Semaste if (!IsValid()) 478254721Semaste return false; 479254721Semaste 480254721Semaste QualType qual_type (GetCanonicalQualType()); 481254721Semaste const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()); 482254721Semaste 483254721Semaste if (builtin_type) 484254721Semaste { 485254721Semaste if (builtin_type->isInteger()) 486254721Semaste { 487254721Semaste is_signed = builtin_type->isSignedInteger(); 488254721Semaste return true; 489254721Semaste } 490254721Semaste } 491254721Semaste 492254721Semaste return false; 493254721Semaste} 494254721Semaste 495254721Semastebool 496254721SemasteClangASTType::IsPointerType (ClangASTType *pointee_type) const 497254721Semaste{ 498254721Semaste if (IsValid()) 499254721Semaste { 500254721Semaste QualType qual_type (GetCanonicalQualType()); 501254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 502254721Semaste switch (type_class) 503254721Semaste { 504254721Semaste case clang::Type::Builtin: 505254721Semaste switch (cast<clang::BuiltinType>(qual_type)->getKind()) 506254721Semaste { 507254721Semaste default: 508254721Semaste break; 509254721Semaste case clang::BuiltinType::ObjCId: 510254721Semaste case clang::BuiltinType::ObjCClass: 511254721Semaste return true; 512254721Semaste } 513254721Semaste return false; 514254721Semaste case clang::Type::ObjCObjectPointer: 515254721Semaste if (pointee_type) 516254721Semaste pointee_type->SetClangType (m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType()); 517254721Semaste return true; 518254721Semaste case clang::Type::BlockPointer: 519254721Semaste if (pointee_type) 520254721Semaste pointee_type->SetClangType (m_ast, cast<BlockPointerType>(qual_type)->getPointeeType()); 521254721Semaste return true; 522254721Semaste case clang::Type::Pointer: 523254721Semaste if (pointee_type) 524254721Semaste pointee_type->SetClangType (m_ast, cast<PointerType>(qual_type)->getPointeeType()); 525254721Semaste return true; 526254721Semaste case clang::Type::MemberPointer: 527254721Semaste if (pointee_type) 528254721Semaste pointee_type->SetClangType (m_ast, cast<MemberPointerType>(qual_type)->getPointeeType()); 529254721Semaste return true; 530254721Semaste case clang::Type::Typedef: 531254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerType(pointee_type); 532254721Semaste case clang::Type::Elaborated: 533254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsPointerType(pointee_type); 534254721Semaste case clang::Type::Paren: 535254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsPointerType(pointee_type); 536254721Semaste default: 537254721Semaste break; 538254721Semaste } 539254721Semaste } 540254721Semaste if (pointee_type) 541254721Semaste pointee_type->Clear(); 542254721Semaste return false; 543254721Semaste} 544254721Semaste 545254721Semaste 546254721Semastebool 547254721SemasteClangASTType::IsPointerOrReferenceType (ClangASTType *pointee_type) const 548254721Semaste{ 549254721Semaste if (IsValid()) 550254721Semaste { 551254721Semaste QualType qual_type (GetCanonicalQualType()); 552254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 553254721Semaste switch (type_class) 554254721Semaste { 555254721Semaste case clang::Type::Builtin: 556254721Semaste switch (cast<clang::BuiltinType>(qual_type)->getKind()) 557254721Semaste { 558254721Semaste default: 559254721Semaste break; 560254721Semaste case clang::BuiltinType::ObjCId: 561254721Semaste case clang::BuiltinType::ObjCClass: 562254721Semaste return true; 563254721Semaste } 564254721Semaste return false; 565254721Semaste case clang::Type::ObjCObjectPointer: 566254721Semaste if (pointee_type) 567254721Semaste pointee_type->SetClangType(m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType()); 568254721Semaste return true; 569254721Semaste case clang::Type::BlockPointer: 570254721Semaste if (pointee_type) 571254721Semaste pointee_type->SetClangType(m_ast, cast<BlockPointerType>(qual_type)->getPointeeType()); 572254721Semaste return true; 573254721Semaste case clang::Type::Pointer: 574254721Semaste if (pointee_type) 575254721Semaste pointee_type->SetClangType(m_ast, cast<PointerType>(qual_type)->getPointeeType()); 576254721Semaste return true; 577254721Semaste case clang::Type::MemberPointer: 578254721Semaste if (pointee_type) 579254721Semaste pointee_type->SetClangType(m_ast, cast<MemberPointerType>(qual_type)->getPointeeType()); 580254721Semaste return true; 581254721Semaste case clang::Type::LValueReference: 582254721Semaste if (pointee_type) 583254721Semaste pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar()); 584254721Semaste return true; 585254721Semaste case clang::Type::RValueReference: 586254721Semaste if (pointee_type) 587254721Semaste pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar()); 588254721Semaste return true; 589254721Semaste case clang::Type::Typedef: 590254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPointerOrReferenceType(pointee_type); 591254721Semaste case clang::Type::Elaborated: 592254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsPointerOrReferenceType(pointee_type); 593254721Semaste case clang::Type::Paren: 594254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsPointerOrReferenceType(pointee_type); 595254721Semaste default: 596254721Semaste break; 597254721Semaste } 598254721Semaste } 599254721Semaste if (pointee_type) 600254721Semaste pointee_type->Clear(); 601254721Semaste return false; 602254721Semaste} 603254721Semaste 604254721Semaste 605254721Semastebool 606254721SemasteClangASTType::IsReferenceType (ClangASTType *pointee_type) const 607254721Semaste{ 608254721Semaste if (IsValid()) 609254721Semaste { 610254721Semaste QualType qual_type (GetCanonicalQualType()); 611254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 612254721Semaste 613254721Semaste switch (type_class) 614254721Semaste { 615254721Semaste case clang::Type::LValueReference: 616254721Semaste if (pointee_type) 617254721Semaste pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar()); 618254721Semaste return true; 619254721Semaste case clang::Type::RValueReference: 620254721Semaste if (pointee_type) 621254721Semaste pointee_type->SetClangType(m_ast, cast<LValueReferenceType>(qual_type)->desugar()); 622254721Semaste return true; 623254721Semaste case clang::Type::Typedef: 624254721Semaste return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsReferenceType(pointee_type); 625254721Semaste case clang::Type::Elaborated: 626254721Semaste return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).IsReferenceType(pointee_type); 627254721Semaste case clang::Type::Paren: 628254721Semaste return ClangASTType(m_ast, cast<clang::ParenType>(qual_type)->desugar()).IsReferenceType(pointee_type); 629254721Semaste 630254721Semaste default: 631254721Semaste break; 632254721Semaste } 633254721Semaste } 634254721Semaste if (pointee_type) 635254721Semaste pointee_type->Clear(); 636254721Semaste return false; 637254721Semaste} 638254721Semaste 639254721Semastebool 640254721SemasteClangASTType::IsFloatingPointType (uint32_t &count, bool &is_complex) const 641254721Semaste{ 642254721Semaste if (IsValid()) 643254721Semaste { 644254721Semaste QualType qual_type (GetCanonicalQualType()); 645254721Semaste 646254721Semaste if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal())) 647254721Semaste { 648254721Semaste clang::BuiltinType::Kind kind = BT->getKind(); 649254721Semaste if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble) 650254721Semaste { 651254721Semaste count = 1; 652254721Semaste is_complex = false; 653254721Semaste return true; 654254721Semaste } 655254721Semaste } 656254721Semaste else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal())) 657254721Semaste { 658254721Semaste if (ClangASTType (m_ast, CT->getElementType()).IsFloatingPointType (count, is_complex)) 659254721Semaste { 660254721Semaste count = 2; 661254721Semaste is_complex = true; 662254721Semaste return true; 663254721Semaste } 664254721Semaste } 665254721Semaste else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal())) 666254721Semaste { 667254721Semaste if (ClangASTType (m_ast, VT->getElementType()).IsFloatingPointType (count, is_complex)) 668254721Semaste { 669254721Semaste count = VT->getNumElements(); 670254721Semaste is_complex = false; 671254721Semaste return true; 672254721Semaste } 673254721Semaste } 674254721Semaste } 675254721Semaste count = 0; 676254721Semaste is_complex = false; 677254721Semaste return false; 678254721Semaste} 679254721Semaste 680254721Semaste 681254721Semastebool 682254721SemasteClangASTType::IsDefined() const 683254721Semaste{ 684254721Semaste if (!IsValid()) 685254721Semaste return false; 686254721Semaste 687254721Semaste QualType qual_type(GetQualType()); 688254721Semaste const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr()); 689254721Semaste if (tag_type) 690254721Semaste { 691254721Semaste TagDecl *tag_decl = tag_type->getDecl(); 692254721Semaste if (tag_decl) 693254721Semaste return tag_decl->isCompleteDefinition(); 694254721Semaste return false; 695254721Semaste } 696254721Semaste else 697254721Semaste { 698254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type); 699254721Semaste if (objc_class_type) 700254721Semaste { 701254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 702254721Semaste if (class_interface_decl) 703254721Semaste return class_interface_decl->getDefinition() != NULL; 704254721Semaste return false; 705254721Semaste } 706254721Semaste } 707254721Semaste return true; 708254721Semaste} 709254721Semaste 710254721Semastebool 711254721SemasteClangASTType::IsObjCClassType () const 712254721Semaste{ 713254721Semaste if (IsValid()) 714254721Semaste { 715254721Semaste QualType qual_type (GetCanonicalQualType()); 716254721Semaste 717254721Semaste const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type); 718254721Semaste 719254721Semaste if (obj_pointer_type) 720254721Semaste return obj_pointer_type->isObjCClassType(); 721254721Semaste } 722254721Semaste return false; 723254721Semaste} 724254721Semaste 725254721Semastebool 726254721SemasteClangASTType::IsObjCObjectOrInterfaceType () const 727254721Semaste{ 728254721Semaste if (IsValid()) 729254721Semaste return GetCanonicalQualType()->isObjCObjectOrInterfaceType(); 730254721Semaste return false; 731254721Semaste} 732254721Semaste 733254721Semastebool 734254721SemasteClangASTType::IsPolymorphicClass () const 735254721Semaste{ 736254721Semaste if (IsValid()) 737254721Semaste { 738254721Semaste QualType qual_type(GetCanonicalQualType()); 739254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 740254721Semaste switch (type_class) 741254721Semaste { 742254721Semaste case clang::Type::Record: 743254721Semaste if (GetCompleteType()) 744254721Semaste { 745254721Semaste const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 746254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 747254721Semaste if (record_decl) 748254721Semaste { 749254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 750254721Semaste if (cxx_record_decl) 751254721Semaste return cxx_record_decl->isPolymorphic(); 752254721Semaste } 753254721Semaste } 754254721Semaste break; 755254721Semaste 756254721Semaste default: 757254721Semaste break; 758254721Semaste } 759254721Semaste } 760254721Semaste return false; 761254721Semaste} 762254721Semaste 763254721Semastebool 764254721SemasteClangASTType::IsPossibleDynamicType (ClangASTType *dynamic_pointee_type, 765254721Semaste bool check_cplusplus, 766254721Semaste bool check_objc) const 767254721Semaste{ 768254721Semaste QualType pointee_qual_type; 769254721Semaste if (m_type) 770254721Semaste { 771254721Semaste QualType qual_type (GetCanonicalQualType()); 772254721Semaste bool success = false; 773254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 774254721Semaste switch (type_class) 775254721Semaste { 776254721Semaste case clang::Type::Builtin: 777254721Semaste if (check_objc && cast<BuiltinType>(qual_type)->getKind() == BuiltinType::ObjCId) 778254721Semaste { 779254721Semaste if (dynamic_pointee_type) 780254721Semaste dynamic_pointee_type->SetClangType(m_ast, m_type); 781254721Semaste return true; 782254721Semaste } 783254721Semaste break; 784254721Semaste 785254721Semaste case clang::Type::ObjCObjectPointer: 786254721Semaste if (check_objc) 787254721Semaste { 788254721Semaste if (dynamic_pointee_type) 789254721Semaste dynamic_pointee_type->SetClangType(m_ast, cast<ObjCObjectPointerType>(qual_type)->getPointeeType()); 790254721Semaste return true; 791254721Semaste } 792254721Semaste break; 793254721Semaste 794254721Semaste case clang::Type::Pointer: 795254721Semaste pointee_qual_type = cast<PointerType>(qual_type)->getPointeeType(); 796254721Semaste success = true; 797254721Semaste break; 798254721Semaste 799254721Semaste case clang::Type::LValueReference: 800254721Semaste case clang::Type::RValueReference: 801254721Semaste pointee_qual_type = cast<ReferenceType>(qual_type)->getPointeeType(); 802254721Semaste success = true; 803254721Semaste break; 804254721Semaste 805254721Semaste case clang::Type::Typedef: 806254721Semaste return ClangASTType (m_ast, 807254721Semaste cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).IsPossibleDynamicType (dynamic_pointee_type, 808254721Semaste check_cplusplus, 809254721Semaste check_objc); 810254721Semaste 811254721Semaste case clang::Type::Elaborated: 812254721Semaste return ClangASTType (m_ast, 813254721Semaste cast<ElaboratedType>(qual_type)->getNamedType()).IsPossibleDynamicType (dynamic_pointee_type, 814254721Semaste check_cplusplus, 815254721Semaste check_objc); 816254721Semaste 817254721Semaste case clang::Type::Paren: 818254721Semaste return ClangASTType (m_ast, 819254721Semaste cast<ParenType>(qual_type)->desugar()).IsPossibleDynamicType (dynamic_pointee_type, 820254721Semaste check_cplusplus, 821254721Semaste check_objc); 822254721Semaste default: 823254721Semaste break; 824254721Semaste } 825254721Semaste 826254721Semaste if (success) 827254721Semaste { 828254721Semaste // Check to make sure what we are pointing too is a possible dynamic C++ type 829254721Semaste // We currently accept any "void *" (in case we have a class that has been 830254721Semaste // watered down to an opaque pointer) and virtual C++ classes. 831254721Semaste const clang::Type::TypeClass pointee_type_class = pointee_qual_type.getCanonicalType()->getTypeClass(); 832254721Semaste switch (pointee_type_class) 833254721Semaste { 834254721Semaste case clang::Type::Builtin: 835254721Semaste switch (cast<BuiltinType>(pointee_qual_type)->getKind()) 836254721Semaste { 837254721Semaste case BuiltinType::UnknownAny: 838254721Semaste case BuiltinType::Void: 839254721Semaste if (dynamic_pointee_type) 840254721Semaste dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type); 841254721Semaste return true; 842254721Semaste 843254721Semaste case BuiltinType::NullPtr: 844254721Semaste case BuiltinType::Bool: 845254721Semaste case BuiltinType::Char_U: 846254721Semaste case BuiltinType::UChar: 847254721Semaste case BuiltinType::WChar_U: 848254721Semaste case BuiltinType::Char16: 849254721Semaste case BuiltinType::Char32: 850254721Semaste case BuiltinType::UShort: 851254721Semaste case BuiltinType::UInt: 852254721Semaste case BuiltinType::ULong: 853254721Semaste case BuiltinType::ULongLong: 854254721Semaste case BuiltinType::UInt128: 855254721Semaste case BuiltinType::Char_S: 856254721Semaste case BuiltinType::SChar: 857254721Semaste case BuiltinType::WChar_S: 858254721Semaste case BuiltinType::Short: 859254721Semaste case BuiltinType::Int: 860254721Semaste case BuiltinType::Long: 861254721Semaste case BuiltinType::LongLong: 862254721Semaste case BuiltinType::Int128: 863254721Semaste case BuiltinType::Float: 864254721Semaste case BuiltinType::Double: 865254721Semaste case BuiltinType::LongDouble: 866254721Semaste case BuiltinType::Dependent: 867254721Semaste case BuiltinType::Overload: 868254721Semaste case BuiltinType::ObjCId: 869254721Semaste case BuiltinType::ObjCClass: 870254721Semaste case BuiltinType::ObjCSel: 871254721Semaste case BuiltinType::BoundMember: 872254721Semaste case BuiltinType::Half: 873254721Semaste case BuiltinType::ARCUnbridgedCast: 874254721Semaste case BuiltinType::PseudoObject: 875254721Semaste case BuiltinType::BuiltinFn: 876254721Semaste case BuiltinType::OCLEvent: 877254721Semaste case BuiltinType::OCLImage1d: 878254721Semaste case BuiltinType::OCLImage1dArray: 879254721Semaste case BuiltinType::OCLImage1dBuffer: 880254721Semaste case BuiltinType::OCLImage2d: 881254721Semaste case BuiltinType::OCLImage2dArray: 882254721Semaste case BuiltinType::OCLImage3d: 883254721Semaste case BuiltinType::OCLSampler: 884254721Semaste break; 885254721Semaste } 886254721Semaste break; 887254721Semaste 888254721Semaste case clang::Type::Record: 889254721Semaste if (check_cplusplus) 890254721Semaste { 891254721Semaste CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl(); 892254721Semaste if (cxx_record_decl) 893254721Semaste { 894254721Semaste bool is_complete = cxx_record_decl->isCompleteDefinition(); 895254721Semaste 896254721Semaste if (is_complete) 897254721Semaste success = cxx_record_decl->isDynamicClass(); 898254721Semaste else 899254721Semaste { 900254721Semaste ClangASTMetadata *metadata = ClangASTContext::GetMetadata (m_ast, cxx_record_decl); 901254721Semaste if (metadata) 902254721Semaste success = metadata->GetIsDynamicCXXType(); 903254721Semaste else 904254721Semaste { 905254721Semaste is_complete = ClangASTType(m_ast, pointee_qual_type).GetCompleteType(); 906254721Semaste if (is_complete) 907254721Semaste success = cxx_record_decl->isDynamicClass(); 908254721Semaste else 909254721Semaste success = false; 910254721Semaste } 911254721Semaste } 912254721Semaste 913254721Semaste if (success) 914254721Semaste { 915254721Semaste if (dynamic_pointee_type) 916254721Semaste dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type); 917254721Semaste return true; 918254721Semaste } 919254721Semaste } 920254721Semaste } 921254721Semaste break; 922254721Semaste 923254721Semaste case clang::Type::ObjCObject: 924254721Semaste case clang::Type::ObjCInterface: 925254721Semaste if (check_objc) 926254721Semaste { 927254721Semaste if (dynamic_pointee_type) 928254721Semaste dynamic_pointee_type->SetClangType(m_ast, pointee_qual_type); 929254721Semaste return true; 930254721Semaste } 931254721Semaste break; 932254721Semaste 933254721Semaste default: 934254721Semaste break; 935254721Semaste } 936254721Semaste } 937254721Semaste } 938254721Semaste if (dynamic_pointee_type) 939254721Semaste dynamic_pointee_type->Clear(); 940254721Semaste return false; 941254721Semaste} 942254721Semaste 943254721Semaste 944254721Semastebool 945254721SemasteClangASTType::IsScalarType () const 946254721Semaste{ 947254721Semaste if (!IsValid()) 948254721Semaste return false; 949254721Semaste 950254721Semaste return (GetTypeInfo (NULL) & eTypeIsScalar) != 0; 951254721Semaste} 952254721Semaste 953254721Semastebool 954254721SemasteClangASTType::IsTypedefType () const 955254721Semaste{ 956254721Semaste if (!IsValid()) 957254721Semaste return false; 958254721Semaste return GetQualType()->getTypeClass() == clang::Type::Typedef; 959254721Semaste} 960254721Semaste 961254721Semastebool 962254721SemasteClangASTType::IsVoidType () const 963254721Semaste{ 964254721Semaste if (!IsValid()) 965254721Semaste return false; 966254721Semaste return GetCanonicalQualType()->isVoidType(); 967254721Semaste} 968254721Semaste 969254721Semastebool 970254721SemasteClangASTType::IsPointerToScalarType () const 971254721Semaste{ 972254721Semaste if (!IsValid()) 973254721Semaste return false; 974254721Semaste 975254721Semaste return IsPointerType() && GetPointeeType().IsScalarType(); 976254721Semaste} 977254721Semaste 978254721Semastebool 979254721SemasteClangASTType::IsArrayOfScalarType () const 980254721Semaste{ 981254721Semaste ClangASTType element_type; 982254721Semaste if (IsArrayType(&element_type, NULL, NULL)) 983254721Semaste return element_type.IsScalarType(); 984254721Semaste return false; 985254721Semaste} 986254721Semaste 987254721Semaste 988254721Semastebool 989254721SemasteClangASTType::GetCXXClassName (std::string &class_name) const 990254721Semaste{ 991254721Semaste if (IsValid()) 992254721Semaste { 993254721Semaste QualType qual_type (GetCanonicalQualType()); 994254721Semaste 995254721Semaste CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 996254721Semaste if (cxx_record_decl) 997254721Semaste { 998254721Semaste class_name.assign (cxx_record_decl->getIdentifier()->getNameStart()); 999254721Semaste return true; 1000254721Semaste } 1001254721Semaste } 1002254721Semaste class_name.clear(); 1003254721Semaste return false; 1004254721Semaste} 1005254721Semaste 1006254721Semaste 1007254721Semastebool 1008254721SemasteClangASTType::IsCXXClassType () const 1009254721Semaste{ 1010254721Semaste if (!IsValid()) 1011254721Semaste return false; 1012254721Semaste 1013254721Semaste QualType qual_type (GetCanonicalQualType()); 1014254721Semaste if (qual_type->getAsCXXRecordDecl() != NULL) 1015254721Semaste return true; 1016254721Semaste return false; 1017254721Semaste} 1018254721Semaste 1019254721Semastebool 1020254721SemasteClangASTType::IsBeingDefined () const 1021254721Semaste{ 1022254721Semaste if (!IsValid()) 1023254721Semaste return false; 1024254721Semaste QualType qual_type (GetCanonicalQualType()); 1025254721Semaste const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type); 1026254721Semaste if (tag_type) 1027254721Semaste return tag_type->isBeingDefined(); 1028254721Semaste return false; 1029254721Semaste} 1030254721Semaste 1031254721Semastebool 1032254721SemasteClangASTType::IsObjCObjectPointerType (ClangASTType *class_type_ptr) 1033254721Semaste{ 1034254721Semaste if (!IsValid()) 1035254721Semaste return false; 1036254721Semaste 1037254721Semaste QualType qual_type (GetCanonicalQualType()); 1038254721Semaste 1039254721Semaste if (qual_type->isObjCObjectPointerType()) 1040254721Semaste { 1041254721Semaste if (class_type_ptr) 1042254721Semaste { 1043254721Semaste if (!qual_type->isObjCClassType() && 1044254721Semaste !qual_type->isObjCIdType()) 1045254721Semaste { 1046254721Semaste const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type); 1047254721Semaste if (obj_pointer_type == NULL) 1048254721Semaste class_type_ptr->Clear(); 1049254721Semaste else 1050254721Semaste class_type_ptr->SetClangType (m_ast, QualType(obj_pointer_type->getInterfaceType(), 0)); 1051254721Semaste } 1052254721Semaste } 1053254721Semaste return true; 1054254721Semaste } 1055254721Semaste if (class_type_ptr) 1056254721Semaste class_type_ptr->Clear(); 1057254721Semaste return false; 1058254721Semaste} 1059254721Semaste 1060254721Semastebool 1061254721SemasteClangASTType::GetObjCClassName (std::string &class_name) 1062254721Semaste{ 1063254721Semaste if (!IsValid()) 1064254721Semaste return false; 1065254721Semaste 1066254721Semaste QualType qual_type (GetCanonicalQualType()); 1067254721Semaste 1068254721Semaste const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(qual_type); 1069254721Semaste if (object_type) 1070254721Semaste { 1071254721Semaste const ObjCInterfaceDecl *interface = object_type->getInterface(); 1072254721Semaste if (interface) 1073254721Semaste { 1074254721Semaste class_name = interface->getNameAsString(); 1075254721Semaste return true; 1076254721Semaste } 1077254721Semaste } 1078254721Semaste return false; 1079254721Semaste} 1080254721Semaste 1081254721Semaste 1082254721Semaste//---------------------------------------------------------------------- 1083254721Semaste// Type Completion 1084254721Semaste//---------------------------------------------------------------------- 1085254721Semaste 1086254721Semastebool 1087254721SemasteClangASTType::GetCompleteType () const 1088254721Semaste{ 1089254721Semaste if (!IsValid()) 1090254721Semaste return false; 1091254721Semaste const bool allow_completion = true; 1092254721Semaste return GetCompleteQualType (m_ast, GetQualType(), allow_completion); 1093254721Semaste} 1094254721Semaste 1095254721Semaste//---------------------------------------------------------------------- 1096254721Semaste// AST related queries 1097254721Semaste//---------------------------------------------------------------------- 1098254721Semastesize_t 1099254721SemasteClangASTType::GetPointerByteSize () const 1100254721Semaste{ 1101254721Semaste if (m_ast) 1102254721Semaste return m_ast->getTypeSize(m_ast->VoidPtrTy) / 8; 1103254721Semaste return 0; 1104254721Semaste} 1105254721Semaste 1106254721SemasteConstString 1107254721SemasteClangASTType::GetConstQualifiedTypeName () const 1108254721Semaste{ 1109254721Semaste return GetConstTypeName (); 1110254721Semaste} 1111254721Semaste 1112254721SemasteConstString 1113254721SemasteClangASTType::GetConstTypeName () const 1114254721Semaste{ 1115254721Semaste if (IsValid()) 1116254721Semaste { 1117263363Semaste ConstString type_name (GetTypeName()); 1118263363Semaste if (type_name) 1119263363Semaste return type_name; 1120254721Semaste } 1121254721Semaste return ConstString("<invalid>"); 1122254721Semaste} 1123254721Semaste 1124263363SemasteConstString 1125254721SemasteClangASTType::GetTypeName () const 1126254721Semaste{ 1127254721Semaste std::string type_name; 1128254721Semaste if (IsValid()) 1129254721Semaste { 1130254721Semaste PrintingPolicy printing_policy (m_ast->getPrintingPolicy()); 1131254721Semaste QualType qual_type(GetQualType()); 1132254721Semaste printing_policy.SuppressTagKeyword = true; 1133254721Semaste printing_policy.LangOpts.WChar = true; 1134254721Semaste const TypedefType *typedef_type = qual_type->getAs<TypedefType>(); 1135254721Semaste if (typedef_type) 1136254721Semaste { 1137254721Semaste const TypedefNameDecl *typedef_decl = typedef_type->getDecl(); 1138269024Semaste type_name = typedef_decl->getQualifiedNameAsString(); 1139254721Semaste } 1140254721Semaste else 1141254721Semaste { 1142254721Semaste type_name = qual_type.getAsString(printing_policy); 1143254721Semaste } 1144254721Semaste } 1145263363Semaste return ConstString(type_name); 1146254721Semaste} 1147254721Semaste 1148254721Semaste 1149254721Semasteuint32_t 1150254721SemasteClangASTType::GetTypeInfo (ClangASTType *pointee_or_element_clang_type) const 1151254721Semaste{ 1152254721Semaste if (!IsValid()) 1153254721Semaste return 0; 1154254721Semaste 1155254721Semaste if (pointee_or_element_clang_type) 1156254721Semaste pointee_or_element_clang_type->Clear(); 1157254721Semaste 1158254721Semaste QualType qual_type (GetQualType()); 1159254721Semaste 1160254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 1161254721Semaste switch (type_class) 1162254721Semaste { 1163254721Semaste case clang::Type::Builtin: 1164254721Semaste { 1165254721Semaste const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()); 1166254721Semaste 1167254721Semaste uint32_t builtin_type_flags = eTypeIsBuiltIn | eTypeHasValue; 1168254721Semaste switch (builtin_type->getKind()) 1169254721Semaste { 1170254721Semaste case clang::BuiltinType::ObjCId: 1171254721Semaste case clang::BuiltinType::ObjCClass: 1172254721Semaste if (pointee_or_element_clang_type) 1173254721Semaste pointee_or_element_clang_type->SetClangType(m_ast, m_ast->ObjCBuiltinClassTy); 1174254721Semaste builtin_type_flags |= eTypeIsPointer | eTypeIsObjC; 1175254721Semaste break; 1176254721Semaste 1177254721Semaste case clang::BuiltinType::ObjCSel: 1178254721Semaste if (pointee_or_element_clang_type) 1179254721Semaste pointee_or_element_clang_type->SetClangType(m_ast, m_ast->CharTy); 1180254721Semaste builtin_type_flags |= eTypeIsPointer | eTypeIsObjC; 1181254721Semaste break; 1182254721Semaste 1183254721Semaste case clang::BuiltinType::Bool: 1184254721Semaste case clang::BuiltinType::Char_U: 1185254721Semaste case clang::BuiltinType::UChar: 1186254721Semaste case clang::BuiltinType::WChar_U: 1187254721Semaste case clang::BuiltinType::Char16: 1188254721Semaste case clang::BuiltinType::Char32: 1189254721Semaste case clang::BuiltinType::UShort: 1190254721Semaste case clang::BuiltinType::UInt: 1191254721Semaste case clang::BuiltinType::ULong: 1192254721Semaste case clang::BuiltinType::ULongLong: 1193254721Semaste case clang::BuiltinType::UInt128: 1194254721Semaste case clang::BuiltinType::Char_S: 1195254721Semaste case clang::BuiltinType::SChar: 1196254721Semaste case clang::BuiltinType::WChar_S: 1197254721Semaste case clang::BuiltinType::Short: 1198254721Semaste case clang::BuiltinType::Int: 1199254721Semaste case clang::BuiltinType::Long: 1200254721Semaste case clang::BuiltinType::LongLong: 1201254721Semaste case clang::BuiltinType::Int128: 1202254721Semaste case clang::BuiltinType::Float: 1203254721Semaste case clang::BuiltinType::Double: 1204254721Semaste case clang::BuiltinType::LongDouble: 1205254721Semaste builtin_type_flags |= eTypeIsScalar; 1206254721Semaste if (builtin_type->isInteger()) 1207254721Semaste { 1208254721Semaste builtin_type_flags |= eTypeIsInteger; 1209254721Semaste if (builtin_type->isSignedInteger()) 1210254721Semaste builtin_type_flags |= eTypeIsSigned; 1211254721Semaste } 1212254721Semaste else if (builtin_type->isFloatingPoint()) 1213254721Semaste builtin_type_flags |= eTypeIsFloat; 1214254721Semaste break; 1215254721Semaste default: 1216254721Semaste break; 1217254721Semaste } 1218254721Semaste return builtin_type_flags; 1219254721Semaste } 1220254721Semaste 1221254721Semaste case clang::Type::BlockPointer: 1222254721Semaste if (pointee_or_element_clang_type) 1223254721Semaste pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType()); 1224254721Semaste return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock; 1225254721Semaste 1226254721Semaste case clang::Type::Complex: 1227254721Semaste { 1228254721Semaste uint32_t complex_type_flags = eTypeIsBuiltIn | eTypeHasValue | eTypeIsComplex; 1229254721Semaste const ComplexType *complex_type = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal()); 1230254721Semaste if (complex_type) 1231254721Semaste { 1232254721Semaste QualType complex_element_type (complex_type->getElementType()); 1233254721Semaste if (complex_element_type->isIntegerType()) 1234254721Semaste complex_type_flags |= eTypeIsFloat; 1235254721Semaste else if (complex_element_type->isFloatingType()) 1236254721Semaste complex_type_flags |= eTypeIsInteger; 1237254721Semaste } 1238254721Semaste return complex_type_flags; 1239254721Semaste } 1240254721Semaste break; 1241254721Semaste 1242254721Semaste case clang::Type::ConstantArray: 1243254721Semaste case clang::Type::DependentSizedArray: 1244254721Semaste case clang::Type::IncompleteArray: 1245254721Semaste case clang::Type::VariableArray: 1246254721Semaste if (pointee_or_element_clang_type) 1247254721Semaste pointee_or_element_clang_type->SetClangType(m_ast, cast<ArrayType>(qual_type.getTypePtr())->getElementType()); 1248254721Semaste return eTypeHasChildren | eTypeIsArray; 1249254721Semaste 1250254721Semaste case clang::Type::DependentName: return 0; 1251254721Semaste case clang::Type::DependentSizedExtVector: return eTypeHasChildren | eTypeIsVector; 1252254721Semaste case clang::Type::DependentTemplateSpecialization: return eTypeIsTemplate; 1253254721Semaste case clang::Type::Decltype: return 0; 1254254721Semaste 1255254721Semaste case clang::Type::Enum: 1256254721Semaste if (pointee_or_element_clang_type) 1257254721Semaste pointee_or_element_clang_type->SetClangType(m_ast, cast<EnumType>(qual_type)->getDecl()->getIntegerType()); 1258254721Semaste return eTypeIsEnumeration | eTypeHasValue; 1259254721Semaste 1260254721Semaste case clang::Type::Elaborated: 1261254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTypeInfo (pointee_or_element_clang_type); 1262254721Semaste case clang::Type::Paren: 1263254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetTypeInfo (pointee_or_element_clang_type); 1264254721Semaste 1265254721Semaste case clang::Type::FunctionProto: return eTypeIsFuncPrototype | eTypeHasValue; 1266254721Semaste case clang::Type::FunctionNoProto: return eTypeIsFuncPrototype | eTypeHasValue; 1267254721Semaste case clang::Type::InjectedClassName: return 0; 1268254721Semaste 1269254721Semaste case clang::Type::LValueReference: 1270254721Semaste case clang::Type::RValueReference: 1271254721Semaste if (pointee_or_element_clang_type) 1272254721Semaste pointee_or_element_clang_type->SetClangType(m_ast, cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType()); 1273254721Semaste return eTypeHasChildren | eTypeIsReference | eTypeHasValue; 1274254721Semaste 1275254721Semaste case clang::Type::MemberPointer: return eTypeIsPointer | eTypeIsMember | eTypeHasValue; 1276254721Semaste 1277254721Semaste case clang::Type::ObjCObjectPointer: 1278254721Semaste if (pointee_or_element_clang_type) 1279254721Semaste pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType()); 1280254721Semaste return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue; 1281254721Semaste 1282254721Semaste case clang::Type::ObjCObject: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; 1283254721Semaste case clang::Type::ObjCInterface: return eTypeHasChildren | eTypeIsObjC | eTypeIsClass; 1284254721Semaste 1285254721Semaste case clang::Type::Pointer: 1286254721Semaste if (pointee_or_element_clang_type) 1287254721Semaste pointee_or_element_clang_type->SetClangType(m_ast, qual_type->getPointeeType()); 1288254721Semaste return eTypeHasChildren | eTypeIsPointer | eTypeHasValue; 1289254721Semaste 1290254721Semaste case clang::Type::Record: 1291254721Semaste if (qual_type->getAsCXXRecordDecl()) 1292254721Semaste return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus; 1293254721Semaste else 1294254721Semaste return eTypeHasChildren | eTypeIsStructUnion; 1295254721Semaste break; 1296254721Semaste case clang::Type::SubstTemplateTypeParm: return eTypeIsTemplate; 1297254721Semaste case clang::Type::TemplateTypeParm: return eTypeIsTemplate; 1298254721Semaste case clang::Type::TemplateSpecialization: return eTypeIsTemplate; 1299254721Semaste 1300254721Semaste case clang::Type::Typedef: 1301254721Semaste return eTypeIsTypedef | ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTypeInfo (pointee_or_element_clang_type); 1302254721Semaste case clang::Type::TypeOfExpr: return 0; 1303254721Semaste case clang::Type::TypeOf: return 0; 1304254721Semaste case clang::Type::UnresolvedUsing: return 0; 1305254721Semaste 1306254721Semaste case clang::Type::ExtVector: 1307254721Semaste case clang::Type::Vector: 1308254721Semaste { 1309254721Semaste uint32_t vector_type_flags = eTypeHasChildren | eTypeIsVector; 1310254721Semaste const VectorType *vector_type = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal()); 1311254721Semaste if (vector_type) 1312254721Semaste { 1313254721Semaste if (vector_type->isIntegerType()) 1314254721Semaste vector_type_flags |= eTypeIsFloat; 1315254721Semaste else if (vector_type->isFloatingType()) 1316254721Semaste vector_type_flags |= eTypeIsInteger; 1317254721Semaste } 1318254721Semaste return vector_type_flags; 1319254721Semaste } 1320254721Semaste default: return 0; 1321254721Semaste } 1322254721Semaste return 0; 1323254721Semaste} 1324254721Semaste 1325254721Semaste 1326254721Semaste 1327254721Semastelldb::LanguageType 1328254721SemasteClangASTType::GetMinimumLanguage () 1329254721Semaste{ 1330254721Semaste if (!IsValid()) 1331254721Semaste return lldb::eLanguageTypeC; 1332254721Semaste 1333254721Semaste // If the type is a reference, then resolve it to what it refers to first: 1334254721Semaste QualType qual_type (GetCanonicalQualType().getNonReferenceType()); 1335254721Semaste if (qual_type->isAnyPointerType()) 1336254721Semaste { 1337254721Semaste if (qual_type->isObjCObjectPointerType()) 1338254721Semaste return lldb::eLanguageTypeObjC; 1339254721Semaste 1340254721Semaste QualType pointee_type (qual_type->getPointeeType()); 1341254721Semaste if (pointee_type->getPointeeCXXRecordDecl() != NULL) 1342254721Semaste return lldb::eLanguageTypeC_plus_plus; 1343254721Semaste if (pointee_type->isObjCObjectOrInterfaceType()) 1344254721Semaste return lldb::eLanguageTypeObjC; 1345254721Semaste if (pointee_type->isObjCClassType()) 1346254721Semaste return lldb::eLanguageTypeObjC; 1347254721Semaste if (pointee_type.getTypePtr() == m_ast->ObjCBuiltinIdTy.getTypePtr()) 1348254721Semaste return lldb::eLanguageTypeObjC; 1349254721Semaste } 1350254721Semaste else 1351254721Semaste { 1352254721Semaste if (qual_type->isObjCObjectOrInterfaceType()) 1353254721Semaste return lldb::eLanguageTypeObjC; 1354254721Semaste if (qual_type->getAsCXXRecordDecl()) 1355254721Semaste return lldb::eLanguageTypeC_plus_plus; 1356254721Semaste switch (qual_type->getTypeClass()) 1357254721Semaste { 1358254721Semaste default: 1359254721Semaste break; 1360254721Semaste case clang::Type::Builtin: 1361254721Semaste switch (cast<BuiltinType>(qual_type)->getKind()) 1362254721Semaste { 1363254721Semaste default: 1364254721Semaste case BuiltinType::Void: 1365254721Semaste case BuiltinType::Bool: 1366254721Semaste case BuiltinType::Char_U: 1367254721Semaste case BuiltinType::UChar: 1368254721Semaste case BuiltinType::WChar_U: 1369254721Semaste case BuiltinType::Char16: 1370254721Semaste case BuiltinType::Char32: 1371254721Semaste case BuiltinType::UShort: 1372254721Semaste case BuiltinType::UInt: 1373254721Semaste case BuiltinType::ULong: 1374254721Semaste case BuiltinType::ULongLong: 1375254721Semaste case BuiltinType::UInt128: 1376254721Semaste case BuiltinType::Char_S: 1377254721Semaste case BuiltinType::SChar: 1378254721Semaste case BuiltinType::WChar_S: 1379254721Semaste case BuiltinType::Short: 1380254721Semaste case BuiltinType::Int: 1381254721Semaste case BuiltinType::Long: 1382254721Semaste case BuiltinType::LongLong: 1383254721Semaste case BuiltinType::Int128: 1384254721Semaste case BuiltinType::Float: 1385254721Semaste case BuiltinType::Double: 1386254721Semaste case BuiltinType::LongDouble: 1387254721Semaste break; 1388254721Semaste 1389254721Semaste case BuiltinType::NullPtr: 1390254721Semaste return eLanguageTypeC_plus_plus; 1391254721Semaste 1392254721Semaste case BuiltinType::ObjCId: 1393254721Semaste case BuiltinType::ObjCClass: 1394254721Semaste case BuiltinType::ObjCSel: 1395254721Semaste return eLanguageTypeObjC; 1396254721Semaste 1397254721Semaste case BuiltinType::Dependent: 1398254721Semaste case BuiltinType::Overload: 1399254721Semaste case BuiltinType::BoundMember: 1400254721Semaste case BuiltinType::UnknownAny: 1401254721Semaste break; 1402254721Semaste } 1403254721Semaste break; 1404254721Semaste case clang::Type::Typedef: 1405254721Semaste return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetMinimumLanguage(); 1406254721Semaste } 1407254721Semaste } 1408254721Semaste return lldb::eLanguageTypeC; 1409254721Semaste} 1410254721Semaste 1411254721Semastelldb::TypeClass 1412254721SemasteClangASTType::GetTypeClass () const 1413254721Semaste{ 1414254721Semaste if (!IsValid()) 1415254721Semaste return lldb::eTypeClassInvalid; 1416254721Semaste 1417254721Semaste QualType qual_type(GetQualType()); 1418254721Semaste 1419254721Semaste switch (qual_type->getTypeClass()) 1420254721Semaste { 1421254721Semaste case clang::Type::UnaryTransform: break; 1422254721Semaste case clang::Type::FunctionNoProto: return lldb::eTypeClassFunction; 1423254721Semaste case clang::Type::FunctionProto: return lldb::eTypeClassFunction; 1424254721Semaste case clang::Type::IncompleteArray: return lldb::eTypeClassArray; 1425254721Semaste case clang::Type::VariableArray: return lldb::eTypeClassArray; 1426254721Semaste case clang::Type::ConstantArray: return lldb::eTypeClassArray; 1427254721Semaste case clang::Type::DependentSizedArray: return lldb::eTypeClassArray; 1428254721Semaste case clang::Type::DependentSizedExtVector: return lldb::eTypeClassVector; 1429254721Semaste case clang::Type::ExtVector: return lldb::eTypeClassVector; 1430254721Semaste case clang::Type::Vector: return lldb::eTypeClassVector; 1431254721Semaste case clang::Type::Builtin: return lldb::eTypeClassBuiltin; 1432254721Semaste case clang::Type::ObjCObjectPointer: return lldb::eTypeClassObjCObjectPointer; 1433254721Semaste case clang::Type::BlockPointer: return lldb::eTypeClassBlockPointer; 1434254721Semaste case clang::Type::Pointer: return lldb::eTypeClassPointer; 1435254721Semaste case clang::Type::LValueReference: return lldb::eTypeClassReference; 1436254721Semaste case clang::Type::RValueReference: return lldb::eTypeClassReference; 1437254721Semaste case clang::Type::MemberPointer: return lldb::eTypeClassMemberPointer; 1438254721Semaste case clang::Type::Complex: 1439254721Semaste if (qual_type->isComplexType()) 1440254721Semaste return lldb::eTypeClassComplexFloat; 1441254721Semaste else 1442254721Semaste return lldb::eTypeClassComplexInteger; 1443254721Semaste case clang::Type::ObjCObject: return lldb::eTypeClassObjCObject; 1444254721Semaste case clang::Type::ObjCInterface: return lldb::eTypeClassObjCInterface; 1445254721Semaste case clang::Type::Record: 1446254721Semaste { 1447254721Semaste const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 1448254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 1449254721Semaste if (record_decl->isUnion()) 1450254721Semaste return lldb::eTypeClassUnion; 1451254721Semaste else if (record_decl->isStruct()) 1452254721Semaste return lldb::eTypeClassStruct; 1453254721Semaste else 1454254721Semaste return lldb::eTypeClassClass; 1455254721Semaste } 1456254721Semaste break; 1457254721Semaste case clang::Type::Enum: return lldb::eTypeClassEnumeration; 1458254721Semaste case clang::Type::Typedef: return lldb::eTypeClassTypedef; 1459254721Semaste case clang::Type::UnresolvedUsing: break; 1460254721Semaste case clang::Type::Paren: 1461254721Semaste return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).GetTypeClass(); 1462254721Semaste case clang::Type::Elaborated: 1463254721Semaste return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTypeClass(); 1464254721Semaste 1465254721Semaste case clang::Type::Attributed: break; 1466254721Semaste case clang::Type::TemplateTypeParm: break; 1467254721Semaste case clang::Type::SubstTemplateTypeParm: break; 1468254721Semaste case clang::Type::SubstTemplateTypeParmPack:break; 1469254721Semaste case clang::Type::Auto: break; 1470254721Semaste case clang::Type::InjectedClassName: break; 1471254721Semaste case clang::Type::DependentName: break; 1472254721Semaste case clang::Type::DependentTemplateSpecialization: break; 1473254721Semaste case clang::Type::PackExpansion: break; 1474254721Semaste 1475254721Semaste case clang::Type::TypeOfExpr: break; 1476254721Semaste case clang::Type::TypeOf: break; 1477254721Semaste case clang::Type::Decltype: break; 1478254721Semaste case clang::Type::TemplateSpecialization: break; 1479254721Semaste case clang::Type::Atomic: break; 1480263508Sdim 1481263508Sdim // pointer type decayed from an array or function type. 1482263508Sdim case clang::Type::Decayed: break; 1483254721Semaste } 1484254721Semaste // We don't know hot to display this type... 1485254721Semaste return lldb::eTypeClassOther; 1486254721Semaste 1487254721Semaste} 1488254721Semaste 1489254721Semastevoid 1490254721SemasteClangASTType::SetClangType (clang::ASTContext *ast, clang::QualType qual_type) 1491254721Semaste{ 1492254721Semaste m_ast = ast; 1493254721Semaste m_type = qual_type.getAsOpaquePtr(); 1494254721Semaste} 1495254721Semaste 1496254721Semasteunsigned 1497254721SemasteClangASTType::GetTypeQualifiers() const 1498254721Semaste{ 1499254721Semaste if (IsValid()) 1500254721Semaste return GetQualType().getQualifiers().getCVRQualifiers(); 1501254721Semaste return 0; 1502254721Semaste} 1503254721Semaste 1504254721Semaste//---------------------------------------------------------------------- 1505254721Semaste// Creating related types 1506254721Semaste//---------------------------------------------------------------------- 1507254721Semaste 1508254721SemasteClangASTType 1509254721SemasteClangASTType::AddConstModifier () const 1510254721Semaste{ 1511254721Semaste if (m_type) 1512254721Semaste { 1513254721Semaste QualType result(GetQualType()); 1514254721Semaste result.addConst(); 1515254721Semaste return ClangASTType (m_ast, result); 1516254721Semaste } 1517254721Semaste return ClangASTType(); 1518254721Semaste} 1519254721Semaste 1520254721SemasteClangASTType 1521254721SemasteClangASTType::AddRestrictModifier () const 1522254721Semaste{ 1523254721Semaste if (m_type) 1524254721Semaste { 1525254721Semaste QualType result(GetQualType()); 1526254721Semaste result.getQualifiers().setRestrict (true); 1527254721Semaste return ClangASTType (m_ast, result); 1528254721Semaste } 1529254721Semaste return ClangASTType(); 1530254721Semaste} 1531254721Semaste 1532254721SemasteClangASTType 1533254721SemasteClangASTType::AddVolatileModifier () const 1534254721Semaste{ 1535254721Semaste if (m_type) 1536254721Semaste { 1537254721Semaste QualType result(GetQualType()); 1538254721Semaste result.getQualifiers().setVolatile (true); 1539254721Semaste return ClangASTType (m_ast, result); 1540254721Semaste } 1541254721Semaste return ClangASTType(); 1542254721Semaste} 1543254721Semaste 1544254721SemasteClangASTType 1545254721SemasteClangASTType::GetArrayElementType (uint64_t& stride) const 1546254721Semaste{ 1547254721Semaste if (IsValid()) 1548254721Semaste { 1549254721Semaste QualType qual_type(GetCanonicalQualType()); 1550254721Semaste 1551254721Semaste ClangASTType element_type (m_ast, qual_type.getTypePtr()->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified()); 1552254721Semaste 1553254721Semaste // TODO: the real stride will be >= this value.. find the real one! 1554254721Semaste stride = element_type.GetByteSize(); 1555254721Semaste 1556254721Semaste return element_type; 1557254721Semaste 1558254721Semaste } 1559254721Semaste return ClangASTType(); 1560254721Semaste} 1561254721Semaste 1562254721SemasteClangASTType 1563254721SemasteClangASTType::GetCanonicalType () const 1564254721Semaste{ 1565254721Semaste if (IsValid()) 1566254721Semaste return ClangASTType (m_ast, GetCanonicalQualType()); 1567254721Semaste return ClangASTType(); 1568254721Semaste} 1569254721Semaste 1570254721Semastestatic QualType 1571254721SemasteGetFullyUnqualifiedType_Impl (ASTContext *ast, QualType qual_type) 1572254721Semaste{ 1573254721Semaste if (qual_type->isPointerType()) 1574254721Semaste qual_type = ast->getPointerType(GetFullyUnqualifiedType_Impl(ast, qual_type->getPointeeType())); 1575254721Semaste else 1576254721Semaste qual_type = qual_type.getUnqualifiedType(); 1577254721Semaste qual_type.removeLocalConst(); 1578254721Semaste qual_type.removeLocalRestrict(); 1579254721Semaste qual_type.removeLocalVolatile(); 1580254721Semaste return qual_type; 1581254721Semaste} 1582254721Semaste 1583254721SemasteClangASTType 1584254721SemasteClangASTType::GetFullyUnqualifiedType () const 1585254721Semaste{ 1586254721Semaste if (IsValid()) 1587254721Semaste return ClangASTType(m_ast, GetFullyUnqualifiedType_Impl(m_ast, GetQualType())); 1588254721Semaste return ClangASTType(); 1589254721Semaste} 1590254721Semaste 1591254721Semaste 1592254721Semasteint 1593254721SemasteClangASTType::GetFunctionArgumentCount () const 1594254721Semaste{ 1595254721Semaste if (IsValid()) 1596254721Semaste { 1597254721Semaste const FunctionProtoType* func = dyn_cast<FunctionProtoType>(GetCanonicalQualType()); 1598254721Semaste if (func) 1599254721Semaste return func->getNumArgs(); 1600254721Semaste } 1601254721Semaste return -1; 1602254721Semaste} 1603254721Semaste 1604254721SemasteClangASTType 1605254721SemasteClangASTType::GetFunctionArgumentTypeAtIndex (size_t idx) 1606254721Semaste{ 1607254721Semaste if (IsValid()) 1608254721Semaste { 1609254721Semaste const FunctionProtoType* func = dyn_cast<FunctionProtoType>(GetCanonicalQualType()); 1610254721Semaste if (func) 1611254721Semaste { 1612254721Semaste const uint32_t num_args = func->getNumArgs(); 1613254721Semaste if (idx < num_args) 1614254721Semaste return ClangASTType(m_ast, func->getArgType(idx)); 1615254721Semaste } 1616254721Semaste } 1617254721Semaste return ClangASTType(); 1618254721Semaste} 1619254721Semaste 1620254721SemasteClangASTType 1621254721SemasteClangASTType::GetFunctionReturnType () const 1622254721Semaste{ 1623254721Semaste if (IsValid()) 1624254721Semaste { 1625254721Semaste QualType qual_type(GetCanonicalQualType()); 1626254721Semaste const FunctionProtoType* func = dyn_cast<FunctionProtoType>(qual_type.getTypePtr()); 1627254721Semaste if (func) 1628254721Semaste return ClangASTType(m_ast, func->getResultType()); 1629254721Semaste } 1630254721Semaste return ClangASTType(); 1631254721Semaste} 1632254721Semaste 1633254721Semaste 1634254721SemasteClangASTType 1635254721SemasteClangASTType::GetLValueReferenceType () const 1636254721Semaste{ 1637254721Semaste if (IsValid()) 1638254721Semaste { 1639254721Semaste return ClangASTType(m_ast, m_ast->getLValueReferenceType(GetQualType())); 1640254721Semaste } 1641254721Semaste return ClangASTType(); 1642254721Semaste} 1643254721Semaste 1644254721SemasteClangASTType 1645254721SemasteClangASTType::GetRValueReferenceType () const 1646254721Semaste{ 1647254721Semaste if (IsValid()) 1648254721Semaste { 1649254721Semaste return ClangASTType(m_ast, m_ast->getRValueReferenceType(GetQualType())); 1650254721Semaste } 1651254721Semaste return ClangASTType(); 1652254721Semaste} 1653254721Semaste 1654254721SemasteClangASTType 1655254721SemasteClangASTType::GetNonReferenceType () const 1656254721Semaste{ 1657254721Semaste if (IsValid()) 1658254721Semaste return ClangASTType(m_ast, GetQualType().getNonReferenceType()); 1659254721Semaste return ClangASTType(); 1660254721Semaste} 1661254721Semaste 1662254721SemasteClangASTType 1663254721SemasteClangASTType::CreateTypedefType (const char *typedef_name, 1664254721Semaste clang::DeclContext *decl_ctx) const 1665254721Semaste{ 1666254721Semaste if (IsValid() && typedef_name && typedef_name[0]) 1667254721Semaste { 1668254721Semaste QualType qual_type (GetQualType()); 1669254721Semaste if (decl_ctx == NULL) 1670254721Semaste decl_ctx = m_ast->getTranslationUnitDecl(); 1671254721Semaste TypedefDecl *decl = TypedefDecl::Create (*m_ast, 1672254721Semaste decl_ctx, 1673254721Semaste SourceLocation(), 1674254721Semaste SourceLocation(), 1675254721Semaste &m_ast->Idents.get(typedef_name), 1676254721Semaste m_ast->getTrivialTypeSourceInfo(qual_type)); 1677254721Semaste 1678254721Semaste decl->setAccess(AS_public); // TODO respect proper access specifier 1679254721Semaste 1680254721Semaste // Get a uniqued QualType for the typedef decl type 1681254721Semaste return ClangASTType (m_ast, m_ast->getTypedefType (decl)); 1682254721Semaste } 1683254721Semaste return ClangASTType(); 1684254721Semaste 1685254721Semaste} 1686254721Semaste 1687254721SemasteClangASTType 1688254721SemasteClangASTType::GetPointeeType () const 1689254721Semaste{ 1690254721Semaste if (m_type) 1691254721Semaste { 1692254721Semaste QualType qual_type(GetQualType()); 1693254721Semaste return ClangASTType (m_ast, qual_type.getTypePtr()->getPointeeType()); 1694254721Semaste } 1695254721Semaste return ClangASTType(); 1696254721Semaste} 1697254721Semaste 1698254721SemasteClangASTType 1699254721SemasteClangASTType::GetPointerType () const 1700254721Semaste{ 1701254721Semaste if (IsValid()) 1702254721Semaste { 1703254721Semaste QualType qual_type (GetQualType()); 1704254721Semaste 1705254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 1706254721Semaste switch (type_class) 1707254721Semaste { 1708254721Semaste case clang::Type::ObjCObject: 1709254721Semaste case clang::Type::ObjCInterface: 1710254721Semaste return ClangASTType(m_ast, m_ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr()); 1711254721Semaste 1712254721Semaste default: 1713254721Semaste return ClangASTType(m_ast, m_ast->getPointerType(qual_type).getAsOpaquePtr()); 1714254721Semaste } 1715254721Semaste } 1716254721Semaste return ClangASTType(); 1717254721Semaste} 1718254721Semaste 1719254721SemasteClangASTType 1720254721SemasteClangASTType::GetTypedefedType () const 1721254721Semaste{ 1722254721Semaste if (IsValid()) 1723254721Semaste { 1724254721Semaste const TypedefType *typedef_type = dyn_cast<TypedefType>(GetQualType()); 1725254721Semaste if (typedef_type) 1726254721Semaste return ClangASTType (m_ast, typedef_type->getDecl()->getUnderlyingType()); 1727254721Semaste } 1728254721Semaste return ClangASTType(); 1729254721Semaste} 1730254721Semaste 1731254721SemasteClangASTType 1732254721SemasteClangASTType::RemoveFastQualifiers () const 1733254721Semaste{ 1734254721Semaste if (m_type) 1735254721Semaste { 1736254721Semaste QualType qual_type(GetQualType()); 1737254721Semaste qual_type.getQualifiers().removeFastQualifiers(); 1738254721Semaste return ClangASTType (m_ast, qual_type); 1739254721Semaste } 1740254721Semaste return ClangASTType(); 1741254721Semaste} 1742254721Semaste 1743254721Semaste 1744254721Semaste//---------------------------------------------------------------------- 1745254721Semaste// Create related types using the current type's AST 1746254721Semaste//---------------------------------------------------------------------- 1747254721Semaste 1748254721SemasteClangASTType 1749254721SemasteClangASTType::GetBasicTypeFromAST (lldb::BasicType basic_type) const 1750254721Semaste{ 1751254721Semaste if (IsValid()) 1752254721Semaste return ClangASTContext::GetBasicType(m_ast, basic_type); 1753254721Semaste return ClangASTType(); 1754254721Semaste} 1755254721Semaste//---------------------------------------------------------------------- 1756254721Semaste// Exploring the type 1757254721Semaste//---------------------------------------------------------------------- 1758254721Semaste 1759254721Semasteuint64_t 1760254721SemasteClangASTType::GetBitSize () const 1761254721Semaste{ 1762254721Semaste if (GetCompleteType ()) 1763254721Semaste { 1764254721Semaste QualType qual_type(GetCanonicalQualType()); 1765254721Semaste const uint32_t bit_size = m_ast->getTypeSize (qual_type); 1766254721Semaste if (bit_size == 0) 1767254721Semaste { 1768254721Semaste if (qual_type->isIncompleteArrayType()) 1769254721Semaste return m_ast->getTypeSize (qual_type->getArrayElementTypeNoTypeQual()->getCanonicalTypeUnqualified()); 1770254721Semaste } 1771254721Semaste if (qual_type->isObjCObjectOrInterfaceType()) 1772254721Semaste return bit_size + m_ast->getTypeSize(m_ast->ObjCBuiltinClassTy); 1773254721Semaste return bit_size; 1774254721Semaste } 1775254721Semaste return 0; 1776254721Semaste} 1777254721Semaste 1778254721Semasteuint64_t 1779254721SemasteClangASTType::GetByteSize () const 1780254721Semaste{ 1781254721Semaste return (GetBitSize () + 7) / 8; 1782254721Semaste} 1783254721Semaste 1784254721Semastesize_t 1785254721SemasteClangASTType::GetTypeBitAlign () const 1786254721Semaste{ 1787254721Semaste if (GetCompleteType ()) 1788254721Semaste return m_ast->getTypeAlign(GetQualType()); 1789254721Semaste return 0; 1790254721Semaste} 1791254721Semaste 1792254721Semaste 1793254721Semastelldb::Encoding 1794254721SemasteClangASTType::GetEncoding (uint64_t &count) const 1795254721Semaste{ 1796254721Semaste if (!IsValid()) 1797254721Semaste return lldb::eEncodingInvalid; 1798254721Semaste 1799254721Semaste count = 1; 1800254721Semaste QualType qual_type(GetCanonicalQualType()); 1801254721Semaste 1802254721Semaste switch (qual_type->getTypeClass()) 1803254721Semaste { 1804254721Semaste case clang::Type::UnaryTransform: 1805254721Semaste break; 1806254721Semaste 1807254721Semaste case clang::Type::FunctionNoProto: 1808254721Semaste case clang::Type::FunctionProto: 1809254721Semaste break; 1810254721Semaste 1811254721Semaste case clang::Type::IncompleteArray: 1812254721Semaste case clang::Type::VariableArray: 1813254721Semaste break; 1814254721Semaste 1815254721Semaste case clang::Type::ConstantArray: 1816254721Semaste break; 1817254721Semaste 1818254721Semaste case clang::Type::ExtVector: 1819254721Semaste case clang::Type::Vector: 1820254721Semaste // TODO: Set this to more than one??? 1821254721Semaste break; 1822254721Semaste 1823254721Semaste case clang::Type::Builtin: 1824254721Semaste switch (cast<BuiltinType>(qual_type)->getKind()) 1825254721Semaste { 1826254721Semaste default: assert(0 && "Unknown builtin type!"); 1827254721Semaste case BuiltinType::Void: 1828254721Semaste break; 1829254721Semaste 1830254721Semaste case BuiltinType::Bool: 1831254721Semaste case BuiltinType::Char_S: 1832254721Semaste case BuiltinType::SChar: 1833254721Semaste case BuiltinType::WChar_S: 1834254721Semaste case BuiltinType::Char16: 1835254721Semaste case BuiltinType::Char32: 1836254721Semaste case BuiltinType::Short: 1837254721Semaste case BuiltinType::Int: 1838254721Semaste case BuiltinType::Long: 1839254721Semaste case BuiltinType::LongLong: 1840254721Semaste case BuiltinType::Int128: return lldb::eEncodingSint; 1841254721Semaste 1842254721Semaste case BuiltinType::Char_U: 1843254721Semaste case BuiltinType::UChar: 1844254721Semaste case BuiltinType::WChar_U: 1845254721Semaste case BuiltinType::UShort: 1846254721Semaste case BuiltinType::UInt: 1847254721Semaste case BuiltinType::ULong: 1848254721Semaste case BuiltinType::ULongLong: 1849254721Semaste case BuiltinType::UInt128: return lldb::eEncodingUint; 1850254721Semaste 1851254721Semaste case BuiltinType::Float: 1852254721Semaste case BuiltinType::Double: 1853254721Semaste case BuiltinType::LongDouble: return lldb::eEncodingIEEE754; 1854254721Semaste 1855254721Semaste case BuiltinType::ObjCClass: 1856254721Semaste case BuiltinType::ObjCId: 1857254721Semaste case BuiltinType::ObjCSel: return lldb::eEncodingUint; 1858254721Semaste 1859254721Semaste case BuiltinType::NullPtr: return lldb::eEncodingUint; 1860254721Semaste } 1861254721Semaste break; 1862254721Semaste // All pointer types are represented as unsigned integer encodings. 1863254721Semaste // We may nee to add a eEncodingPointer if we ever need to know the 1864254721Semaste // difference 1865254721Semaste case clang::Type::ObjCObjectPointer: 1866254721Semaste case clang::Type::BlockPointer: 1867254721Semaste case clang::Type::Pointer: 1868254721Semaste case clang::Type::LValueReference: 1869254721Semaste case clang::Type::RValueReference: 1870254721Semaste case clang::Type::MemberPointer: return lldb::eEncodingUint; 1871254721Semaste case clang::Type::Complex: 1872254721Semaste { 1873254721Semaste lldb::Encoding encoding = lldb::eEncodingIEEE754; 1874254721Semaste if (qual_type->isComplexType()) 1875254721Semaste encoding = lldb::eEncodingIEEE754; 1876254721Semaste else 1877254721Semaste { 1878254721Semaste const ComplexType *complex_type = qual_type->getAsComplexIntegerType(); 1879254721Semaste if (complex_type) 1880254721Semaste encoding = ClangASTType(m_ast, complex_type->getElementType()).GetEncoding(count); 1881254721Semaste else 1882254721Semaste encoding = lldb::eEncodingSint; 1883254721Semaste } 1884254721Semaste count = 2; 1885254721Semaste return encoding; 1886254721Semaste } 1887254721Semaste 1888254721Semaste case clang::Type::ObjCInterface: break; 1889254721Semaste case clang::Type::Record: break; 1890254721Semaste case clang::Type::Enum: return lldb::eEncodingSint; 1891254721Semaste case clang::Type::Typedef: 1892254721Semaste return ClangASTType(m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetEncoding(count); 1893254721Semaste 1894254721Semaste case clang::Type::Elaborated: 1895254721Semaste return ClangASTType(m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetEncoding(count); 1896254721Semaste 1897254721Semaste case clang::Type::Paren: 1898254721Semaste return ClangASTType(m_ast, cast<ParenType>(qual_type)->desugar()).GetEncoding(count); 1899254721Semaste 1900254721Semaste case clang::Type::DependentSizedArray: 1901254721Semaste case clang::Type::DependentSizedExtVector: 1902254721Semaste case clang::Type::UnresolvedUsing: 1903254721Semaste case clang::Type::Attributed: 1904254721Semaste case clang::Type::TemplateTypeParm: 1905254721Semaste case clang::Type::SubstTemplateTypeParm: 1906254721Semaste case clang::Type::SubstTemplateTypeParmPack: 1907254721Semaste case clang::Type::Auto: 1908254721Semaste case clang::Type::InjectedClassName: 1909254721Semaste case clang::Type::DependentName: 1910254721Semaste case clang::Type::DependentTemplateSpecialization: 1911254721Semaste case clang::Type::PackExpansion: 1912254721Semaste case clang::Type::ObjCObject: 1913254721Semaste 1914254721Semaste case clang::Type::TypeOfExpr: 1915254721Semaste case clang::Type::TypeOf: 1916254721Semaste case clang::Type::Decltype: 1917254721Semaste case clang::Type::TemplateSpecialization: 1918254721Semaste case clang::Type::Atomic: 1919254721Semaste break; 1920263508Sdim 1921263508Sdim // pointer type decayed from an array or function type. 1922263508Sdim case clang::Type::Decayed: 1923263508Sdim break; 1924254721Semaste } 1925254721Semaste count = 0; 1926254721Semaste return lldb::eEncodingInvalid; 1927254721Semaste} 1928254721Semaste 1929254721Semastelldb::Format 1930254721SemasteClangASTType::GetFormat () const 1931254721Semaste{ 1932254721Semaste if (!IsValid()) 1933254721Semaste return lldb::eFormatDefault; 1934254721Semaste 1935254721Semaste QualType qual_type(GetCanonicalQualType()); 1936254721Semaste 1937254721Semaste switch (qual_type->getTypeClass()) 1938254721Semaste { 1939254721Semaste case clang::Type::UnaryTransform: 1940254721Semaste break; 1941254721Semaste 1942254721Semaste case clang::Type::FunctionNoProto: 1943254721Semaste case clang::Type::FunctionProto: 1944254721Semaste break; 1945254721Semaste 1946254721Semaste case clang::Type::IncompleteArray: 1947254721Semaste case clang::Type::VariableArray: 1948254721Semaste break; 1949254721Semaste 1950254721Semaste case clang::Type::ConstantArray: 1951254721Semaste return lldb::eFormatVoid; // no value 1952254721Semaste 1953254721Semaste case clang::Type::ExtVector: 1954254721Semaste case clang::Type::Vector: 1955254721Semaste break; 1956254721Semaste 1957254721Semaste case clang::Type::Builtin: 1958254721Semaste switch (cast<BuiltinType>(qual_type)->getKind()) 1959254721Semaste { 1960254721Semaste //default: assert(0 && "Unknown builtin type!"); 1961254721Semaste case BuiltinType::UnknownAny: 1962254721Semaste case BuiltinType::Void: 1963254721Semaste case BuiltinType::BoundMember: 1964254721Semaste break; 1965254721Semaste 1966254721Semaste case BuiltinType::Bool: return lldb::eFormatBoolean; 1967254721Semaste case BuiltinType::Char_S: 1968254721Semaste case BuiltinType::SChar: 1969254721Semaste case BuiltinType::WChar_S: 1970254721Semaste case BuiltinType::Char_U: 1971254721Semaste case BuiltinType::UChar: 1972254721Semaste case BuiltinType::WChar_U: return lldb::eFormatChar; 1973254721Semaste case BuiltinType::Char16: return lldb::eFormatUnicode16; 1974254721Semaste case BuiltinType::Char32: return lldb::eFormatUnicode32; 1975254721Semaste case BuiltinType::UShort: return lldb::eFormatUnsigned; 1976254721Semaste case BuiltinType::Short: return lldb::eFormatDecimal; 1977254721Semaste case BuiltinType::UInt: return lldb::eFormatUnsigned; 1978254721Semaste case BuiltinType::Int: return lldb::eFormatDecimal; 1979254721Semaste case BuiltinType::ULong: return lldb::eFormatUnsigned; 1980254721Semaste case BuiltinType::Long: return lldb::eFormatDecimal; 1981254721Semaste case BuiltinType::ULongLong: return lldb::eFormatUnsigned; 1982254721Semaste case BuiltinType::LongLong: return lldb::eFormatDecimal; 1983254721Semaste case BuiltinType::UInt128: return lldb::eFormatUnsigned; 1984254721Semaste case BuiltinType::Int128: return lldb::eFormatDecimal; 1985254721Semaste case BuiltinType::Float: return lldb::eFormatFloat; 1986254721Semaste case BuiltinType::Double: return lldb::eFormatFloat; 1987254721Semaste case BuiltinType::LongDouble: return lldb::eFormatFloat; 1988254721Semaste case BuiltinType::NullPtr: 1989254721Semaste case BuiltinType::Overload: 1990254721Semaste case BuiltinType::Dependent: 1991254721Semaste case BuiltinType::ObjCId: 1992254721Semaste case BuiltinType::ObjCClass: 1993254721Semaste case BuiltinType::ObjCSel: 1994254721Semaste case BuiltinType::Half: 1995254721Semaste case BuiltinType::ARCUnbridgedCast: 1996254721Semaste case BuiltinType::PseudoObject: 1997254721Semaste case BuiltinType::BuiltinFn: 1998254721Semaste case BuiltinType::OCLEvent: 1999254721Semaste case BuiltinType::OCLImage1d: 2000254721Semaste case BuiltinType::OCLImage1dArray: 2001254721Semaste case BuiltinType::OCLImage1dBuffer: 2002254721Semaste case BuiltinType::OCLImage2d: 2003254721Semaste case BuiltinType::OCLImage2dArray: 2004254721Semaste case BuiltinType::OCLImage3d: 2005254721Semaste case BuiltinType::OCLSampler: 2006254721Semaste return lldb::eFormatHex; 2007254721Semaste } 2008254721Semaste break; 2009254721Semaste case clang::Type::ObjCObjectPointer: return lldb::eFormatHex; 2010254721Semaste case clang::Type::BlockPointer: return lldb::eFormatHex; 2011254721Semaste case clang::Type::Pointer: return lldb::eFormatHex; 2012254721Semaste case clang::Type::LValueReference: 2013254721Semaste case clang::Type::RValueReference: return lldb::eFormatHex; 2014254721Semaste case clang::Type::MemberPointer: break; 2015254721Semaste case clang::Type::Complex: 2016254721Semaste { 2017254721Semaste if (qual_type->isComplexType()) 2018254721Semaste return lldb::eFormatComplex; 2019254721Semaste else 2020254721Semaste return lldb::eFormatComplexInteger; 2021254721Semaste } 2022254721Semaste case clang::Type::ObjCInterface: break; 2023254721Semaste case clang::Type::Record: break; 2024254721Semaste case clang::Type::Enum: return lldb::eFormatEnum; 2025254721Semaste case clang::Type::Typedef: 2026254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetFormat(); 2027254721Semaste case clang::Type::Auto: 2028254721Semaste return ClangASTType (m_ast, cast<AutoType>(qual_type)->desugar()).GetFormat(); 2029254721Semaste case clang::Type::Paren: 2030254721Semaste return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetFormat(); 2031254721Semaste case clang::Type::Elaborated: 2032254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetFormat(); 2033254721Semaste case clang::Type::DependentSizedArray: 2034254721Semaste case clang::Type::DependentSizedExtVector: 2035254721Semaste case clang::Type::UnresolvedUsing: 2036254721Semaste case clang::Type::Attributed: 2037254721Semaste case clang::Type::TemplateTypeParm: 2038254721Semaste case clang::Type::SubstTemplateTypeParm: 2039254721Semaste case clang::Type::SubstTemplateTypeParmPack: 2040254721Semaste case clang::Type::InjectedClassName: 2041254721Semaste case clang::Type::DependentName: 2042254721Semaste case clang::Type::DependentTemplateSpecialization: 2043254721Semaste case clang::Type::PackExpansion: 2044254721Semaste case clang::Type::ObjCObject: 2045254721Semaste 2046254721Semaste case clang::Type::TypeOfExpr: 2047254721Semaste case clang::Type::TypeOf: 2048254721Semaste case clang::Type::Decltype: 2049254721Semaste case clang::Type::TemplateSpecialization: 2050254721Semaste case clang::Type::Atomic: 2051254721Semaste break; 2052263508Sdim 2053263508Sdim // pointer type decayed from an array or function type. 2054263508Sdim case clang::Type::Decayed: 2055263508Sdim break; 2056254721Semaste } 2057254721Semaste // We don't know hot to display this type... 2058254721Semaste return lldb::eFormatBytes; 2059254721Semaste} 2060254721Semaste 2061254721Semastestatic bool 2062254721SemasteObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass) 2063254721Semaste{ 2064254721Semaste while (class_interface_decl) 2065254721Semaste { 2066254721Semaste if (class_interface_decl->ivar_size() > 0) 2067254721Semaste return true; 2068254721Semaste 2069254721Semaste if (check_superclass) 2070254721Semaste class_interface_decl = class_interface_decl->getSuperClass(); 2071254721Semaste else 2072254721Semaste break; 2073254721Semaste } 2074254721Semaste return false; 2075254721Semaste} 2076254721Semaste 2077254721Semasteuint32_t 2078254721SemasteClangASTType::GetNumChildren (bool omit_empty_base_classes) const 2079254721Semaste{ 2080254721Semaste if (!IsValid()) 2081254721Semaste return 0; 2082254721Semaste 2083254721Semaste uint32_t num_children = 0; 2084254721Semaste QualType qual_type(GetQualType()); 2085254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2086254721Semaste switch (type_class) 2087254721Semaste { 2088254721Semaste case clang::Type::Builtin: 2089254721Semaste switch (cast<BuiltinType>(qual_type)->getKind()) 2090254721Semaste { 2091254721Semaste case BuiltinType::ObjCId: // child is Class 2092254721Semaste case BuiltinType::ObjCClass: // child is Class 2093254721Semaste num_children = 1; 2094254721Semaste break; 2095254721Semaste 2096254721Semaste default: 2097254721Semaste break; 2098254721Semaste } 2099254721Semaste break; 2100254721Semaste 2101254721Semaste case clang::Type::Complex: return 0; 2102254721Semaste 2103254721Semaste case clang::Type::Record: 2104254721Semaste if (GetCompleteQualType (m_ast, qual_type)) 2105254721Semaste { 2106254721Semaste const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 2107254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 2108254721Semaste assert(record_decl); 2109254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 2110254721Semaste if (cxx_record_decl) 2111254721Semaste { 2112254721Semaste if (omit_empty_base_classes) 2113254721Semaste { 2114254721Semaste // Check each base classes to see if it or any of its 2115254721Semaste // base classes contain any fields. This can help 2116254721Semaste // limit the noise in variable views by not having to 2117254721Semaste // show base classes that contain no members. 2118254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 2119254721Semaste for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 2120254721Semaste base_class != base_class_end; 2121254721Semaste ++base_class) 2122254721Semaste { 2123254721Semaste const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 2124254721Semaste 2125254721Semaste // Skip empty base classes 2126254721Semaste if (ClangASTContext::RecordHasFields(base_class_decl) == false) 2127254721Semaste continue; 2128254721Semaste 2129254721Semaste num_children++; 2130254721Semaste } 2131254721Semaste } 2132254721Semaste else 2133254721Semaste { 2134254721Semaste // Include all base classes 2135254721Semaste num_children += cxx_record_decl->getNumBases(); 2136254721Semaste } 2137254721Semaste 2138254721Semaste } 2139254721Semaste RecordDecl::field_iterator field, field_end; 2140254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) 2141254721Semaste ++num_children; 2142254721Semaste } 2143254721Semaste break; 2144254721Semaste 2145254721Semaste case clang::Type::ObjCObject: 2146254721Semaste case clang::Type::ObjCInterface: 2147254721Semaste if (GetCompleteQualType (m_ast, qual_type)) 2148254721Semaste { 2149254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 2150254721Semaste assert (objc_class_type); 2151254721Semaste if (objc_class_type) 2152254721Semaste { 2153254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2154254721Semaste 2155254721Semaste if (class_interface_decl) 2156254721Semaste { 2157254721Semaste 2158254721Semaste ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 2159254721Semaste if (superclass_interface_decl) 2160254721Semaste { 2161254721Semaste if (omit_empty_base_classes) 2162254721Semaste { 2163254721Semaste if (ObjCDeclHasIVars (superclass_interface_decl, true)) 2164254721Semaste ++num_children; 2165254721Semaste } 2166254721Semaste else 2167254721Semaste ++num_children; 2168254721Semaste } 2169254721Semaste 2170254721Semaste num_children += class_interface_decl->ivar_size(); 2171254721Semaste } 2172254721Semaste } 2173254721Semaste } 2174254721Semaste break; 2175254721Semaste 2176254721Semaste case clang::Type::ObjCObjectPointer: 2177254721Semaste { 2178254721Semaste const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr()); 2179254721Semaste QualType pointee_type = pointer_type->getPointeeType(); 2180254721Semaste uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes); 2181254721Semaste // If this type points to a simple type, then it has 1 child 2182254721Semaste if (num_pointee_children == 0) 2183254721Semaste num_children = 1; 2184254721Semaste else 2185254721Semaste num_children = num_pointee_children; 2186254721Semaste } 2187254721Semaste break; 2188254721Semaste 2189254721Semaste case clang::Type::Vector: 2190254721Semaste case clang::Type::ExtVector: 2191254721Semaste num_children = cast<VectorType>(qual_type.getTypePtr())->getNumElements(); 2192254721Semaste break; 2193254721Semaste 2194254721Semaste case clang::Type::ConstantArray: 2195254721Semaste num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue(); 2196254721Semaste break; 2197254721Semaste 2198254721Semaste case clang::Type::Pointer: 2199254721Semaste { 2200254721Semaste const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); 2201254721Semaste QualType pointee_type (pointer_type->getPointeeType()); 2202254721Semaste uint32_t num_pointee_children = ClangASTType (m_ast,pointee_type).GetNumChildren (omit_empty_base_classes); 2203254721Semaste if (num_pointee_children == 0) 2204254721Semaste { 2205254721Semaste // We have a pointer to a pointee type that claims it has no children. 2206254721Semaste // We will want to look at 2207254721Semaste num_children = ClangASTType (m_ast, pointee_type).GetNumPointeeChildren(); 2208254721Semaste } 2209254721Semaste else 2210254721Semaste num_children = num_pointee_children; 2211254721Semaste } 2212254721Semaste break; 2213254721Semaste 2214254721Semaste case clang::Type::LValueReference: 2215254721Semaste case clang::Type::RValueReference: 2216254721Semaste { 2217254721Semaste const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 2218254721Semaste QualType pointee_type = reference_type->getPointeeType(); 2219254721Semaste uint32_t num_pointee_children = ClangASTType (m_ast, pointee_type).GetNumChildren (omit_empty_base_classes); 2220254721Semaste // If this type points to a simple type, then it has 1 child 2221254721Semaste if (num_pointee_children == 0) 2222254721Semaste num_children = 1; 2223254721Semaste else 2224254721Semaste num_children = num_pointee_children; 2225254721Semaste } 2226254721Semaste break; 2227254721Semaste 2228254721Semaste 2229254721Semaste case clang::Type::Typedef: 2230254721Semaste num_children = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumChildren (omit_empty_base_classes); 2231254721Semaste break; 2232254721Semaste 2233254721Semaste case clang::Type::Elaborated: 2234254721Semaste num_children = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumChildren (omit_empty_base_classes); 2235254721Semaste break; 2236254721Semaste 2237254721Semaste case clang::Type::Paren: 2238254721Semaste num_children = ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetNumChildren (omit_empty_base_classes); 2239254721Semaste break; 2240254721Semaste default: 2241254721Semaste break; 2242254721Semaste } 2243254721Semaste return num_children; 2244254721Semaste} 2245254721Semaste 2246254721Semastelldb::BasicType 2247254721SemasteClangASTType::GetBasicTypeEnumeration () const 2248254721Semaste{ 2249254721Semaste if (IsValid()) 2250254721Semaste { 2251254721Semaste QualType qual_type(GetQualType()); 2252254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2253254721Semaste if (type_class == clang::Type::Builtin) 2254254721Semaste { 2255254721Semaste switch (cast<clang::BuiltinType>(qual_type)->getKind()) 2256254721Semaste { 2257254721Semaste case clang::BuiltinType::Void: return eBasicTypeVoid; 2258254721Semaste case clang::BuiltinType::Bool: return eBasicTypeBool; 2259254721Semaste case clang::BuiltinType::Char_S: return eBasicTypeSignedChar; 2260254721Semaste case clang::BuiltinType::Char_U: return eBasicTypeUnsignedChar; 2261254721Semaste case clang::BuiltinType::Char16: return eBasicTypeChar16; 2262254721Semaste case clang::BuiltinType::Char32: return eBasicTypeChar32; 2263254721Semaste case clang::BuiltinType::UChar: return eBasicTypeUnsignedChar; 2264254721Semaste case clang::BuiltinType::SChar: return eBasicTypeSignedChar; 2265254721Semaste case clang::BuiltinType::WChar_S: return eBasicTypeSignedWChar; 2266254721Semaste case clang::BuiltinType::WChar_U: return eBasicTypeUnsignedWChar; 2267254721Semaste case clang::BuiltinType::Short: return eBasicTypeShort; 2268254721Semaste case clang::BuiltinType::UShort: return eBasicTypeUnsignedShort; 2269254721Semaste case clang::BuiltinType::Int: return eBasicTypeInt; 2270254721Semaste case clang::BuiltinType::UInt: return eBasicTypeUnsignedInt; 2271254721Semaste case clang::BuiltinType::Long: return eBasicTypeLong; 2272254721Semaste case clang::BuiltinType::ULong: return eBasicTypeUnsignedLong; 2273254721Semaste case clang::BuiltinType::LongLong: return eBasicTypeLongLong; 2274254721Semaste case clang::BuiltinType::ULongLong: return eBasicTypeUnsignedLongLong; 2275254721Semaste case clang::BuiltinType::Int128: return eBasicTypeInt128; 2276254721Semaste case clang::BuiltinType::UInt128: return eBasicTypeUnsignedInt128; 2277254721Semaste 2278254721Semaste case clang::BuiltinType::Half: return eBasicTypeHalf; 2279254721Semaste case clang::BuiltinType::Float: return eBasicTypeFloat; 2280254721Semaste case clang::BuiltinType::Double: return eBasicTypeDouble; 2281254721Semaste case clang::BuiltinType::LongDouble:return eBasicTypeLongDouble; 2282254721Semaste 2283254721Semaste case clang::BuiltinType::NullPtr: return eBasicTypeNullPtr; 2284254721Semaste case clang::BuiltinType::ObjCId: return eBasicTypeObjCID; 2285254721Semaste case clang::BuiltinType::ObjCClass: return eBasicTypeObjCClass; 2286254721Semaste case clang::BuiltinType::ObjCSel: return eBasicTypeObjCSel; 2287254721Semaste case clang::BuiltinType::Dependent: 2288254721Semaste case clang::BuiltinType::Overload: 2289254721Semaste case clang::BuiltinType::BoundMember: 2290254721Semaste case clang::BuiltinType::PseudoObject: 2291254721Semaste case clang::BuiltinType::UnknownAny: 2292254721Semaste case clang::BuiltinType::BuiltinFn: 2293254721Semaste case clang::BuiltinType::ARCUnbridgedCast: 2294254721Semaste case clang::BuiltinType::OCLEvent: 2295254721Semaste case clang::BuiltinType::OCLImage1d: 2296254721Semaste case clang::BuiltinType::OCLImage1dArray: 2297254721Semaste case clang::BuiltinType::OCLImage1dBuffer: 2298254721Semaste case clang::BuiltinType::OCLImage2d: 2299254721Semaste case clang::BuiltinType::OCLImage2dArray: 2300254721Semaste case clang::BuiltinType::OCLImage3d: 2301254721Semaste case clang::BuiltinType::OCLSampler: 2302254721Semaste return eBasicTypeOther; 2303254721Semaste } 2304254721Semaste } 2305254721Semaste } 2306254721Semaste return eBasicTypeInvalid; 2307254721Semaste} 2308254721Semaste 2309254721Semaste 2310254721Semaste#pragma mark Aggregate Types 2311254721Semaste 2312254721Semasteuint32_t 2313254721SemasteClangASTType::GetNumDirectBaseClasses () const 2314254721Semaste{ 2315254721Semaste if (!IsValid()) 2316254721Semaste return 0; 2317254721Semaste 2318254721Semaste uint32_t count = 0; 2319254721Semaste QualType qual_type(GetCanonicalQualType()); 2320254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2321254721Semaste switch (type_class) 2322254721Semaste { 2323254721Semaste case clang::Type::Record: 2324254721Semaste if (GetCompleteType()) 2325254721Semaste { 2326254721Semaste const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2327254721Semaste if (cxx_record_decl) 2328254721Semaste count = cxx_record_decl->getNumBases(); 2329254721Semaste } 2330254721Semaste break; 2331254721Semaste 2332254721Semaste case clang::Type::ObjCObjectPointer: 2333263363Semaste count = GetPointeeType().GetNumDirectBaseClasses(); 2334263363Semaste break; 2335263363Semaste 2336263363Semaste case clang::Type::ObjCObject: 2337254721Semaste if (GetCompleteType()) 2338254721Semaste { 2339263363Semaste const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); 2340254721Semaste if (objc_class_type) 2341254721Semaste { 2342263363Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2343263363Semaste 2344254721Semaste if (class_interface_decl && class_interface_decl->getSuperClass()) 2345254721Semaste count = 1; 2346254721Semaste } 2347254721Semaste } 2348254721Semaste break; 2349254721Semaste case clang::Type::ObjCInterface: 2350254721Semaste if (GetCompleteType()) 2351254721Semaste { 2352263363Semaste const ObjCInterfaceType *objc_interface_type = qual_type->getAs<ObjCInterfaceType>(); 2353263363Semaste if (objc_interface_type) 2354254721Semaste { 2355263363Semaste ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); 2356254721Semaste 2357254721Semaste if (class_interface_decl && class_interface_decl->getSuperClass()) 2358254721Semaste count = 1; 2359254721Semaste } 2360254721Semaste } 2361254721Semaste break; 2362254721Semaste 2363254721Semaste 2364254721Semaste case clang::Type::Typedef: 2365254721Semaste count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumDirectBaseClasses (); 2366254721Semaste break; 2367254721Semaste 2368254721Semaste case clang::Type::Elaborated: 2369254721Semaste count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumDirectBaseClasses (); 2370254721Semaste break; 2371254721Semaste 2372254721Semaste case clang::Type::Paren: 2373254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumDirectBaseClasses (); 2374254721Semaste 2375254721Semaste default: 2376254721Semaste break; 2377254721Semaste } 2378254721Semaste return count; 2379254721Semaste} 2380254721Semaste 2381254721Semasteuint32_t 2382254721SemasteClangASTType::GetNumVirtualBaseClasses () const 2383254721Semaste{ 2384254721Semaste if (!IsValid()) 2385254721Semaste return 0; 2386254721Semaste 2387254721Semaste uint32_t count = 0; 2388254721Semaste QualType qual_type(GetCanonicalQualType()); 2389254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2390254721Semaste switch (type_class) 2391254721Semaste { 2392254721Semaste case clang::Type::Record: 2393254721Semaste if (GetCompleteType()) 2394254721Semaste { 2395254721Semaste const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2396254721Semaste if (cxx_record_decl) 2397254721Semaste count = cxx_record_decl->getNumVBases(); 2398254721Semaste } 2399254721Semaste break; 2400254721Semaste 2401254721Semaste case clang::Type::Typedef: 2402254721Semaste count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumVirtualBaseClasses(); 2403254721Semaste break; 2404254721Semaste 2405254721Semaste case clang::Type::Elaborated: 2406254721Semaste count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumVirtualBaseClasses(); 2407254721Semaste break; 2408254721Semaste 2409254721Semaste case clang::Type::Paren: 2410254721Semaste count = ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumVirtualBaseClasses(); 2411254721Semaste break; 2412254721Semaste 2413254721Semaste default: 2414254721Semaste break; 2415254721Semaste } 2416254721Semaste return count; 2417254721Semaste} 2418254721Semaste 2419254721Semasteuint32_t 2420254721SemasteClangASTType::GetNumFields () const 2421254721Semaste{ 2422254721Semaste if (!IsValid()) 2423254721Semaste return 0; 2424254721Semaste 2425254721Semaste uint32_t count = 0; 2426254721Semaste QualType qual_type(GetCanonicalQualType()); 2427254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2428254721Semaste switch (type_class) 2429254721Semaste { 2430254721Semaste case clang::Type::Record: 2431254721Semaste if (GetCompleteType()) 2432254721Semaste { 2433254721Semaste const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr()); 2434254721Semaste if (record_type) 2435254721Semaste { 2436254721Semaste RecordDecl *record_decl = record_type->getDecl(); 2437254721Semaste if (record_decl) 2438254721Semaste { 2439254721Semaste uint32_t field_idx = 0; 2440254721Semaste RecordDecl::field_iterator field, field_end; 2441254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field) 2442254721Semaste ++field_idx; 2443254721Semaste count = field_idx; 2444254721Semaste } 2445254721Semaste } 2446254721Semaste } 2447254721Semaste break; 2448254721Semaste 2449254721Semaste case clang::Type::Typedef: 2450254721Semaste count = ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumFields(); 2451254721Semaste break; 2452254721Semaste 2453254721Semaste case clang::Type::Elaborated: 2454254721Semaste count = ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumFields(); 2455254721Semaste break; 2456254721Semaste 2457254721Semaste case clang::Type::Paren: 2458254721Semaste count = ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumFields(); 2459254721Semaste break; 2460254721Semaste 2461254721Semaste case clang::Type::ObjCObjectPointer: 2462254721Semaste if (GetCompleteType()) 2463254721Semaste { 2464254721Semaste const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); 2465254721Semaste if (objc_class_type) 2466254721Semaste { 2467254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); 2468254721Semaste 2469254721Semaste if (class_interface_decl) 2470254721Semaste count = class_interface_decl->ivar_size(); 2471254721Semaste } 2472254721Semaste } 2473254721Semaste break; 2474254721Semaste 2475254721Semaste case clang::Type::ObjCObject: 2476254721Semaste case clang::Type::ObjCInterface: 2477254721Semaste if (GetCompleteType()) 2478254721Semaste { 2479254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 2480254721Semaste if (objc_class_type) 2481254721Semaste { 2482254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2483254721Semaste 2484254721Semaste if (class_interface_decl) 2485254721Semaste count = class_interface_decl->ivar_size(); 2486254721Semaste } 2487254721Semaste } 2488254721Semaste break; 2489254721Semaste 2490254721Semaste default: 2491254721Semaste break; 2492254721Semaste } 2493254721Semaste return count; 2494254721Semaste} 2495254721Semaste 2496254721SemasteClangASTType 2497254721SemasteClangASTType::GetDirectBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const 2498254721Semaste{ 2499254721Semaste if (!IsValid()) 2500254721Semaste return ClangASTType(); 2501254721Semaste 2502254721Semaste QualType qual_type(GetCanonicalQualType()); 2503254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2504254721Semaste switch (type_class) 2505254721Semaste { 2506254721Semaste case clang::Type::Record: 2507254721Semaste if (GetCompleteType()) 2508254721Semaste { 2509254721Semaste const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2510254721Semaste if (cxx_record_decl) 2511254721Semaste { 2512254721Semaste uint32_t curr_idx = 0; 2513254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 2514254721Semaste for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 2515254721Semaste base_class != base_class_end; 2516254721Semaste ++base_class, ++curr_idx) 2517254721Semaste { 2518254721Semaste if (curr_idx == idx) 2519254721Semaste { 2520254721Semaste if (bit_offset_ptr) 2521254721Semaste { 2522254721Semaste const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl); 2523254721Semaste const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 2524254721Semaste if (base_class->isVirtual()) 2525254721Semaste *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 2526254721Semaste else 2527254721Semaste *bit_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; 2528254721Semaste } 2529254721Semaste return ClangASTType (m_ast, base_class->getType()); 2530254721Semaste } 2531254721Semaste } 2532254721Semaste } 2533254721Semaste } 2534254721Semaste break; 2535254721Semaste 2536254721Semaste case clang::Type::ObjCObjectPointer: 2537263363Semaste return GetPointeeType().GetDirectBaseClassAtIndex(idx,bit_offset_ptr); 2538263363Semaste 2539263363Semaste case clang::Type::ObjCObject: 2540254721Semaste if (idx == 0 && GetCompleteType()) 2541254721Semaste { 2542263363Semaste const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType(); 2543254721Semaste if (objc_class_type) 2544254721Semaste { 2545263363Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2546263363Semaste 2547254721Semaste if (class_interface_decl) 2548254721Semaste { 2549254721Semaste ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 2550254721Semaste if (superclass_interface_decl) 2551254721Semaste { 2552254721Semaste if (bit_offset_ptr) 2553254721Semaste *bit_offset_ptr = 0; 2554254721Semaste return ClangASTType (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl)); 2555254721Semaste } 2556254721Semaste } 2557254721Semaste } 2558254721Semaste } 2559254721Semaste break; 2560254721Semaste case clang::Type::ObjCInterface: 2561254721Semaste if (idx == 0 && GetCompleteType()) 2562254721Semaste { 2563263363Semaste const ObjCObjectType *objc_interface_type = qual_type->getAs<ObjCInterfaceType>(); 2564263363Semaste if (objc_interface_type) 2565254721Semaste { 2566263363Semaste ObjCInterfaceDecl *class_interface_decl = objc_interface_type->getInterface(); 2567254721Semaste 2568254721Semaste if (class_interface_decl) 2569254721Semaste { 2570254721Semaste ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 2571254721Semaste if (superclass_interface_decl) 2572254721Semaste { 2573254721Semaste if (bit_offset_ptr) 2574254721Semaste *bit_offset_ptr = 0; 2575254721Semaste return ClangASTType (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl)); 2576254721Semaste } 2577254721Semaste } 2578254721Semaste } 2579254721Semaste } 2580254721Semaste break; 2581254721Semaste 2582254721Semaste 2583254721Semaste case clang::Type::Typedef: 2584254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); 2585254721Semaste 2586254721Semaste case clang::Type::Elaborated: 2587254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); 2588254721Semaste 2589254721Semaste case clang::Type::Paren: 2590254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetDirectBaseClassAtIndex (idx, bit_offset_ptr); 2591254721Semaste 2592254721Semaste default: 2593254721Semaste break; 2594254721Semaste } 2595254721Semaste return ClangASTType(); 2596254721Semaste} 2597254721Semaste 2598254721SemasteClangASTType 2599254721SemasteClangASTType::GetVirtualBaseClassAtIndex (size_t idx, uint32_t *bit_offset_ptr) const 2600254721Semaste{ 2601254721Semaste if (!IsValid()) 2602254721Semaste return ClangASTType(); 2603254721Semaste 2604254721Semaste QualType qual_type(GetCanonicalQualType()); 2605254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2606254721Semaste switch (type_class) 2607254721Semaste { 2608254721Semaste case clang::Type::Record: 2609254721Semaste if (GetCompleteType()) 2610254721Semaste { 2611254721Semaste const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 2612254721Semaste if (cxx_record_decl) 2613254721Semaste { 2614254721Semaste uint32_t curr_idx = 0; 2615254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 2616254721Semaste for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end(); 2617254721Semaste base_class != base_class_end; 2618254721Semaste ++base_class, ++curr_idx) 2619254721Semaste { 2620254721Semaste if (curr_idx == idx) 2621254721Semaste { 2622254721Semaste if (bit_offset_ptr) 2623254721Semaste { 2624254721Semaste const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(cxx_record_decl); 2625254721Semaste const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 2626254721Semaste *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 2627254721Semaste 2628254721Semaste } 2629254721Semaste return ClangASTType (m_ast, base_class->getType()); 2630254721Semaste } 2631254721Semaste } 2632254721Semaste } 2633254721Semaste } 2634254721Semaste break; 2635254721Semaste 2636254721Semaste case clang::Type::Typedef: 2637254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); 2638254721Semaste 2639254721Semaste case clang::Type::Elaborated: 2640254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); 2641254721Semaste 2642254721Semaste case clang::Type::Paren: 2643254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetVirtualBaseClassAtIndex (idx, bit_offset_ptr); 2644254721Semaste 2645254721Semaste default: 2646254721Semaste break; 2647254721Semaste } 2648254721Semaste return ClangASTType(); 2649254721Semaste} 2650254721Semaste 2651254721Semastestatic clang_type_t 2652254721SemasteGetObjCFieldAtIndex (clang::ASTContext *ast, 2653254721Semaste ObjCInterfaceDecl *class_interface_decl, 2654254721Semaste size_t idx, 2655254721Semaste std::string& name, 2656254721Semaste uint64_t *bit_offset_ptr, 2657254721Semaste uint32_t *bitfield_bit_size_ptr, 2658254721Semaste bool *is_bitfield_ptr) 2659254721Semaste{ 2660254721Semaste if (class_interface_decl) 2661254721Semaste { 2662254721Semaste if (idx < (class_interface_decl->ivar_size())) 2663254721Semaste { 2664254721Semaste ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 2665254721Semaste uint32_t ivar_idx = 0; 2666254721Semaste 2667254721Semaste for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx) 2668254721Semaste { 2669254721Semaste if (ivar_idx == idx) 2670254721Semaste { 2671254721Semaste const ObjCIvarDecl* ivar_decl = *ivar_pos; 2672254721Semaste 2673254721Semaste QualType ivar_qual_type(ivar_decl->getType()); 2674254721Semaste 2675254721Semaste name.assign(ivar_decl->getNameAsString()); 2676254721Semaste 2677254721Semaste if (bit_offset_ptr) 2678254721Semaste { 2679254721Semaste const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl); 2680254721Semaste *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx); 2681254721Semaste } 2682254721Semaste 2683254721Semaste const bool is_bitfield = ivar_pos->isBitField(); 2684254721Semaste 2685254721Semaste if (bitfield_bit_size_ptr) 2686254721Semaste { 2687254721Semaste *bitfield_bit_size_ptr = 0; 2688254721Semaste 2689254721Semaste if (is_bitfield && ast) 2690254721Semaste { 2691254721Semaste Expr *bitfield_bit_size_expr = ivar_pos->getBitWidth(); 2692254721Semaste llvm::APSInt bitfield_apsint; 2693254721Semaste if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *ast)) 2694254721Semaste { 2695254721Semaste *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); 2696254721Semaste } 2697254721Semaste } 2698254721Semaste } 2699254721Semaste if (is_bitfield_ptr) 2700254721Semaste *is_bitfield_ptr = is_bitfield; 2701254721Semaste 2702254721Semaste return ivar_qual_type.getAsOpaquePtr(); 2703254721Semaste } 2704254721Semaste } 2705254721Semaste } 2706254721Semaste } 2707254721Semaste return NULL; 2708254721Semaste} 2709254721Semaste 2710254721SemasteClangASTType 2711254721SemasteClangASTType::GetFieldAtIndex (size_t idx, 2712254721Semaste std::string& name, 2713254721Semaste uint64_t *bit_offset_ptr, 2714254721Semaste uint32_t *bitfield_bit_size_ptr, 2715254721Semaste bool *is_bitfield_ptr) const 2716254721Semaste{ 2717254721Semaste if (!IsValid()) 2718254721Semaste return ClangASTType(); 2719254721Semaste 2720254721Semaste QualType qual_type(GetCanonicalQualType()); 2721254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2722254721Semaste switch (type_class) 2723254721Semaste { 2724254721Semaste case clang::Type::Record: 2725254721Semaste if (GetCompleteType()) 2726254721Semaste { 2727254721Semaste const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 2728254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 2729254721Semaste uint32_t field_idx = 0; 2730254721Semaste RecordDecl::field_iterator field, field_end; 2731254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx) 2732254721Semaste { 2733254721Semaste if (idx == field_idx) 2734254721Semaste { 2735254721Semaste // Print the member type if requested 2736254721Semaste // Print the member name and equal sign 2737254721Semaste name.assign(field->getNameAsString()); 2738254721Semaste 2739254721Semaste // Figure out the type byte size (field_type_info.first) and 2740254721Semaste // alignment (field_type_info.second) from the AST context. 2741254721Semaste if (bit_offset_ptr) 2742254721Semaste { 2743254721Semaste const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); 2744254721Semaste *bit_offset_ptr = record_layout.getFieldOffset (field_idx); 2745254721Semaste } 2746254721Semaste 2747254721Semaste const bool is_bitfield = field->isBitField(); 2748254721Semaste 2749254721Semaste if (bitfield_bit_size_ptr) 2750254721Semaste { 2751254721Semaste *bitfield_bit_size_ptr = 0; 2752254721Semaste 2753254721Semaste if (is_bitfield) 2754254721Semaste { 2755254721Semaste Expr *bitfield_bit_size_expr = field->getBitWidth(); 2756254721Semaste llvm::APSInt bitfield_apsint; 2757254721Semaste if (bitfield_bit_size_expr && bitfield_bit_size_expr->EvaluateAsInt(bitfield_apsint, *m_ast)) 2758254721Semaste { 2759254721Semaste *bitfield_bit_size_ptr = bitfield_apsint.getLimitedValue(); 2760254721Semaste } 2761254721Semaste } 2762254721Semaste } 2763254721Semaste if (is_bitfield_ptr) 2764254721Semaste *is_bitfield_ptr = is_bitfield; 2765254721Semaste 2766254721Semaste return ClangASTType (m_ast, field->getType()); 2767254721Semaste } 2768254721Semaste } 2769254721Semaste } 2770254721Semaste break; 2771254721Semaste 2772254721Semaste case clang::Type::ObjCObjectPointer: 2773254721Semaste if (GetCompleteType()) 2774254721Semaste { 2775254721Semaste const ObjCObjectPointerType *objc_class_type = qual_type->getAsObjCInterfacePointerType(); 2776254721Semaste if (objc_class_type) 2777254721Semaste { 2778254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterfaceDecl(); 2779254721Semaste return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); 2780254721Semaste } 2781254721Semaste } 2782254721Semaste break; 2783254721Semaste 2784254721Semaste case clang::Type::ObjCObject: 2785254721Semaste case clang::Type::ObjCInterface: 2786254721Semaste if (GetCompleteType()) 2787254721Semaste { 2788254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 2789254721Semaste assert (objc_class_type); 2790254721Semaste if (objc_class_type) 2791254721Semaste { 2792254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 2793254721Semaste return ClangASTType (m_ast, GetObjCFieldAtIndex(m_ast, class_interface_decl, idx, name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); 2794254721Semaste } 2795254721Semaste } 2796254721Semaste break; 2797254721Semaste 2798254721Semaste 2799254721Semaste case clang::Type::Typedef: 2800254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()). 2801254721Semaste GetFieldAtIndex (idx, 2802254721Semaste name, 2803254721Semaste bit_offset_ptr, 2804254721Semaste bitfield_bit_size_ptr, 2805254721Semaste is_bitfield_ptr); 2806254721Semaste 2807254721Semaste case clang::Type::Elaborated: 2808254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()). 2809254721Semaste GetFieldAtIndex (idx, 2810254721Semaste name, 2811254721Semaste bit_offset_ptr, 2812254721Semaste bitfield_bit_size_ptr, 2813254721Semaste is_bitfield_ptr); 2814254721Semaste 2815254721Semaste case clang::Type::Paren: 2816254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()). 2817254721Semaste GetFieldAtIndex (idx, 2818254721Semaste name, 2819254721Semaste bit_offset_ptr, 2820254721Semaste bitfield_bit_size_ptr, 2821254721Semaste is_bitfield_ptr); 2822254721Semaste 2823254721Semaste default: 2824254721Semaste break; 2825254721Semaste } 2826254721Semaste return ClangASTType(); 2827254721Semaste} 2828254721Semaste 2829254721Semasteuint32_t 2830254721SemasteClangASTType::GetIndexOfFieldWithName (const char* name, 2831254721Semaste ClangASTType* field_clang_type_ptr, 2832254721Semaste uint64_t *bit_offset_ptr, 2833254721Semaste uint32_t *bitfield_bit_size_ptr, 2834254721Semaste bool *is_bitfield_ptr) const 2835254721Semaste{ 2836254721Semaste unsigned count = GetNumFields(); 2837254721Semaste std::string field_name; 2838254721Semaste for (unsigned index = 0; index < count; index++) 2839254721Semaste { 2840254721Semaste ClangASTType field_clang_type (GetFieldAtIndex(index, field_name, bit_offset_ptr, bitfield_bit_size_ptr, is_bitfield_ptr)); 2841254721Semaste if (strcmp(field_name.c_str(), name) == 0) 2842254721Semaste { 2843254721Semaste if (field_clang_type_ptr) 2844254721Semaste *field_clang_type_ptr = field_clang_type; 2845254721Semaste return index; 2846254721Semaste } 2847254721Semaste } 2848254721Semaste return UINT32_MAX; 2849254721Semaste} 2850254721Semaste 2851254721Semaste// If a pointer to a pointee type (the clang_type arg) says that it has no 2852254721Semaste// children, then we either need to trust it, or override it and return a 2853254721Semaste// different result. For example, an "int *" has one child that is an integer, 2854254721Semaste// but a function pointer doesn't have any children. Likewise if a Record type 2855254721Semaste// claims it has no children, then there really is nothing to show. 2856254721Semasteuint32_t 2857254721SemasteClangASTType::GetNumPointeeChildren () const 2858254721Semaste{ 2859254721Semaste if (!IsValid()) 2860254721Semaste return 0; 2861254721Semaste 2862254721Semaste QualType qual_type(GetCanonicalQualType()); 2863254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 2864254721Semaste switch (type_class) 2865254721Semaste { 2866254721Semaste case clang::Type::Builtin: 2867254721Semaste switch (cast<clang::BuiltinType>(qual_type)->getKind()) 2868254721Semaste { 2869254721Semaste case clang::BuiltinType::UnknownAny: 2870254721Semaste case clang::BuiltinType::Void: 2871254721Semaste case clang::BuiltinType::NullPtr: 2872254721Semaste case clang::BuiltinType::OCLEvent: 2873254721Semaste case clang::BuiltinType::OCLImage1d: 2874254721Semaste case clang::BuiltinType::OCLImage1dArray: 2875254721Semaste case clang::BuiltinType::OCLImage1dBuffer: 2876254721Semaste case clang::BuiltinType::OCLImage2d: 2877254721Semaste case clang::BuiltinType::OCLImage2dArray: 2878254721Semaste case clang::BuiltinType::OCLImage3d: 2879254721Semaste case clang::BuiltinType::OCLSampler: 2880254721Semaste return 0; 2881254721Semaste case clang::BuiltinType::Bool: 2882254721Semaste case clang::BuiltinType::Char_U: 2883254721Semaste case clang::BuiltinType::UChar: 2884254721Semaste case clang::BuiltinType::WChar_U: 2885254721Semaste case clang::BuiltinType::Char16: 2886254721Semaste case clang::BuiltinType::Char32: 2887254721Semaste case clang::BuiltinType::UShort: 2888254721Semaste case clang::BuiltinType::UInt: 2889254721Semaste case clang::BuiltinType::ULong: 2890254721Semaste case clang::BuiltinType::ULongLong: 2891254721Semaste case clang::BuiltinType::UInt128: 2892254721Semaste case clang::BuiltinType::Char_S: 2893254721Semaste case clang::BuiltinType::SChar: 2894254721Semaste case clang::BuiltinType::WChar_S: 2895254721Semaste case clang::BuiltinType::Short: 2896254721Semaste case clang::BuiltinType::Int: 2897254721Semaste case clang::BuiltinType::Long: 2898254721Semaste case clang::BuiltinType::LongLong: 2899254721Semaste case clang::BuiltinType::Int128: 2900254721Semaste case clang::BuiltinType::Float: 2901254721Semaste case clang::BuiltinType::Double: 2902254721Semaste case clang::BuiltinType::LongDouble: 2903254721Semaste case clang::BuiltinType::Dependent: 2904254721Semaste case clang::BuiltinType::Overload: 2905254721Semaste case clang::BuiltinType::ObjCId: 2906254721Semaste case clang::BuiltinType::ObjCClass: 2907254721Semaste case clang::BuiltinType::ObjCSel: 2908254721Semaste case clang::BuiltinType::BoundMember: 2909254721Semaste case clang::BuiltinType::Half: 2910254721Semaste case clang::BuiltinType::ARCUnbridgedCast: 2911254721Semaste case clang::BuiltinType::PseudoObject: 2912254721Semaste case clang::BuiltinType::BuiltinFn: 2913254721Semaste return 1; 2914254721Semaste } 2915254721Semaste break; 2916254721Semaste 2917254721Semaste case clang::Type::Complex: return 1; 2918254721Semaste case clang::Type::Pointer: return 1; 2919254721Semaste case clang::Type::BlockPointer: return 0; // If block pointers don't have debug info, then no children for them 2920254721Semaste case clang::Type::LValueReference: return 1; 2921254721Semaste case clang::Type::RValueReference: return 1; 2922254721Semaste case clang::Type::MemberPointer: return 0; 2923254721Semaste case clang::Type::ConstantArray: return 0; 2924254721Semaste case clang::Type::IncompleteArray: return 0; 2925254721Semaste case clang::Type::VariableArray: return 0; 2926254721Semaste case clang::Type::DependentSizedArray: return 0; 2927254721Semaste case clang::Type::DependentSizedExtVector: return 0; 2928254721Semaste case clang::Type::Vector: return 0; 2929254721Semaste case clang::Type::ExtVector: return 0; 2930254721Semaste case clang::Type::FunctionProto: return 0; // When we function pointers, they have no children... 2931254721Semaste case clang::Type::FunctionNoProto: return 0; // When we function pointers, they have no children... 2932254721Semaste case clang::Type::UnresolvedUsing: return 0; 2933254721Semaste case clang::Type::Paren: return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetNumPointeeChildren (); 2934254721Semaste case clang::Type::Typedef: return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumPointeeChildren (); 2935254721Semaste case clang::Type::Elaborated: return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumPointeeChildren (); 2936254721Semaste case clang::Type::TypeOfExpr: return 0; 2937254721Semaste case clang::Type::TypeOf: return 0; 2938254721Semaste case clang::Type::Decltype: return 0; 2939254721Semaste case clang::Type::Record: return 0; 2940254721Semaste case clang::Type::Enum: return 1; 2941254721Semaste case clang::Type::TemplateTypeParm: return 1; 2942254721Semaste case clang::Type::SubstTemplateTypeParm: return 1; 2943254721Semaste case clang::Type::TemplateSpecialization: return 1; 2944254721Semaste case clang::Type::InjectedClassName: return 0; 2945254721Semaste case clang::Type::DependentName: return 1; 2946254721Semaste case clang::Type::DependentTemplateSpecialization: return 1; 2947254721Semaste case clang::Type::ObjCObject: return 0; 2948254721Semaste case clang::Type::ObjCInterface: return 0; 2949254721Semaste case clang::Type::ObjCObjectPointer: return 1; 2950254721Semaste default: 2951254721Semaste break; 2952254721Semaste } 2953254721Semaste return 0; 2954254721Semaste} 2955254721Semaste 2956254721Semaste 2957254721SemasteClangASTType 2958254721SemasteClangASTType::GetChildClangTypeAtIndex (ExecutionContext *exe_ctx, 2959254721Semaste const char *parent_name, 2960254721Semaste size_t idx, 2961254721Semaste bool transparent_pointers, 2962254721Semaste bool omit_empty_base_classes, 2963254721Semaste bool ignore_array_bounds, 2964254721Semaste std::string& child_name, 2965254721Semaste uint32_t &child_byte_size, 2966254721Semaste int32_t &child_byte_offset, 2967254721Semaste uint32_t &child_bitfield_bit_size, 2968254721Semaste uint32_t &child_bitfield_bit_offset, 2969254721Semaste bool &child_is_base_class, 2970254721Semaste bool &child_is_deref_of_parent) const 2971254721Semaste{ 2972254721Semaste if (!IsValid()) 2973254721Semaste return ClangASTType(); 2974254721Semaste 2975254721Semaste QualType parent_qual_type(GetCanonicalQualType()); 2976254721Semaste const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass(); 2977254721Semaste child_bitfield_bit_size = 0; 2978254721Semaste child_bitfield_bit_offset = 0; 2979254721Semaste child_is_base_class = false; 2980254721Semaste 2981254721Semaste const bool idx_is_valid = idx < GetNumChildren (omit_empty_base_classes); 2982254721Semaste uint32_t bit_offset; 2983254721Semaste switch (parent_type_class) 2984254721Semaste { 2985254721Semaste case clang::Type::Builtin: 2986254721Semaste if (idx_is_valid) 2987254721Semaste { 2988254721Semaste switch (cast<clang::BuiltinType>(parent_qual_type)->getKind()) 2989254721Semaste { 2990254721Semaste case clang::BuiltinType::ObjCId: 2991254721Semaste case clang::BuiltinType::ObjCClass: 2992254721Semaste child_name = "isa"; 2993254721Semaste child_byte_size = m_ast->getTypeSize(m_ast->ObjCBuiltinClassTy) / CHAR_BIT; 2994254721Semaste return ClangASTType (m_ast, m_ast->ObjCBuiltinClassTy); 2995254721Semaste 2996254721Semaste default: 2997254721Semaste break; 2998254721Semaste } 2999254721Semaste } 3000254721Semaste break; 3001254721Semaste 3002254721Semaste case clang::Type::Record: 3003254721Semaste if (idx_is_valid && GetCompleteType()) 3004254721Semaste { 3005254721Semaste const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr()); 3006254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 3007254721Semaste assert(record_decl); 3008254721Semaste const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); 3009254721Semaste uint32_t child_idx = 0; 3010254721Semaste 3011254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3012254721Semaste if (cxx_record_decl) 3013254721Semaste { 3014254721Semaste // We might have base classes to print out first 3015254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3016254721Semaste for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3017254721Semaste base_class != base_class_end; 3018254721Semaste ++base_class) 3019254721Semaste { 3020254721Semaste const CXXRecordDecl *base_class_decl = NULL; 3021254721Semaste 3022254721Semaste // Skip empty base classes 3023254721Semaste if (omit_empty_base_classes) 3024254721Semaste { 3025254721Semaste base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3026254721Semaste if (ClangASTContext::RecordHasFields(base_class_decl) == false) 3027254721Semaste continue; 3028254721Semaste } 3029254721Semaste 3030254721Semaste if (idx == child_idx) 3031254721Semaste { 3032254721Semaste if (base_class_decl == NULL) 3033254721Semaste base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3034254721Semaste 3035254721Semaste 3036254721Semaste if (base_class->isVirtual()) 3037254721Semaste bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 3038254721Semaste else 3039254721Semaste bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; 3040254721Semaste 3041254721Semaste // Base classes should be a multiple of 8 bits in size 3042254721Semaste child_byte_offset = bit_offset/8; 3043254721Semaste ClangASTType base_class_clang_type(m_ast, base_class->getType()); 3044263363Semaste child_name = base_class_clang_type.GetTypeName().AsCString(""); 3045254721Semaste uint64_t base_class_clang_type_bit_size = base_class_clang_type.GetBitSize(); 3046254721Semaste 3047254721Semaste // Base classes bit sizes should be a multiple of 8 bits in size 3048254721Semaste assert (base_class_clang_type_bit_size % 8 == 0); 3049254721Semaste child_byte_size = base_class_clang_type_bit_size / 8; 3050254721Semaste child_is_base_class = true; 3051254721Semaste return base_class_clang_type; 3052254721Semaste } 3053254721Semaste // We don't increment the child index in the for loop since we might 3054254721Semaste // be skipping empty base classes 3055254721Semaste ++child_idx; 3056254721Semaste } 3057254721Semaste } 3058254721Semaste // Make sure index is in range... 3059254721Semaste uint32_t field_idx = 0; 3060254721Semaste RecordDecl::field_iterator field, field_end; 3061254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) 3062254721Semaste { 3063254721Semaste if (idx == child_idx) 3064254721Semaste { 3065254721Semaste // Print the member type if requested 3066254721Semaste // Print the member name and equal sign 3067254721Semaste child_name.assign(field->getNameAsString().c_str()); 3068254721Semaste 3069254721Semaste // Figure out the type byte size (field_type_info.first) and 3070254721Semaste // alignment (field_type_info.second) from the AST context. 3071254721Semaste ClangASTType field_clang_type (m_ast, field->getType()); 3072254721Semaste assert(field_idx < record_layout.getFieldCount()); 3073254721Semaste child_byte_size = field_clang_type.GetByteSize(); 3074254721Semaste 3075254721Semaste // Figure out the field offset within the current struct/union/class type 3076254721Semaste bit_offset = record_layout.getFieldOffset (field_idx); 3077254721Semaste child_byte_offset = bit_offset / 8; 3078254721Semaste if (ClangASTContext::FieldIsBitfield (m_ast, *field, child_bitfield_bit_size)) 3079254721Semaste child_bitfield_bit_offset = bit_offset % 8; 3080254721Semaste 3081254721Semaste return field_clang_type; 3082254721Semaste } 3083254721Semaste } 3084254721Semaste } 3085254721Semaste break; 3086254721Semaste 3087254721Semaste case clang::Type::ObjCObject: 3088254721Semaste case clang::Type::ObjCInterface: 3089254721Semaste if (idx_is_valid && GetCompleteType()) 3090254721Semaste { 3091254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr()); 3092254721Semaste assert (objc_class_type); 3093254721Semaste if (objc_class_type) 3094254721Semaste { 3095254721Semaste uint32_t child_idx = 0; 3096254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3097254721Semaste 3098254721Semaste if (class_interface_decl) 3099254721Semaste { 3100254721Semaste 3101254721Semaste const ASTRecordLayout &interface_layout = m_ast->getASTObjCInterfaceLayout(class_interface_decl); 3102254721Semaste ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3103254721Semaste if (superclass_interface_decl) 3104254721Semaste { 3105254721Semaste if (omit_empty_base_classes) 3106254721Semaste { 3107254721Semaste ClangASTType base_class_clang_type (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl)); 3108254721Semaste if (base_class_clang_type.GetNumChildren(omit_empty_base_classes) > 0) 3109254721Semaste { 3110254721Semaste if (idx == 0) 3111254721Semaste { 3112254721Semaste QualType ivar_qual_type(m_ast->getObjCInterfaceType(superclass_interface_decl)); 3113254721Semaste 3114254721Semaste 3115254721Semaste child_name.assign(superclass_interface_decl->getNameAsString().c_str()); 3116254721Semaste 3117254721Semaste std::pair<uint64_t, unsigned> ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr()); 3118254721Semaste 3119254721Semaste child_byte_size = ivar_type_info.first / 8; 3120254721Semaste child_byte_offset = 0; 3121254721Semaste child_is_base_class = true; 3122254721Semaste 3123254721Semaste return ClangASTType (m_ast, ivar_qual_type); 3124254721Semaste } 3125254721Semaste 3126254721Semaste ++child_idx; 3127254721Semaste } 3128254721Semaste } 3129254721Semaste else 3130254721Semaste ++child_idx; 3131254721Semaste } 3132254721Semaste 3133254721Semaste const uint32_t superclass_idx = child_idx; 3134254721Semaste 3135254721Semaste if (idx < (child_idx + class_interface_decl->ivar_size())) 3136254721Semaste { 3137254721Semaste ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 3138254721Semaste 3139254721Semaste for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos) 3140254721Semaste { 3141254721Semaste if (child_idx == idx) 3142254721Semaste { 3143254721Semaste ObjCIvarDecl* ivar_decl = *ivar_pos; 3144254721Semaste 3145254721Semaste QualType ivar_qual_type(ivar_decl->getType()); 3146254721Semaste 3147254721Semaste child_name.assign(ivar_decl->getNameAsString().c_str()); 3148254721Semaste 3149254721Semaste std::pair<uint64_t, unsigned> ivar_type_info = m_ast->getTypeInfo(ivar_qual_type.getTypePtr()); 3150254721Semaste 3151254721Semaste child_byte_size = ivar_type_info.first / 8; 3152254721Semaste 3153254721Semaste // Figure out the field offset within the current struct/union/class type 3154254721Semaste // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since 3155254721Semaste // that doesn't account for the space taken up by unbacked properties, or from 3156254721Semaste // the changing size of base classes that are newer than this class. 3157254721Semaste // So if we have a process around that we can ask about this object, do so. 3158254721Semaste child_byte_offset = LLDB_INVALID_IVAR_OFFSET; 3159254721Semaste Process *process = NULL; 3160254721Semaste if (exe_ctx) 3161254721Semaste process = exe_ctx->GetProcessPtr(); 3162254721Semaste if (process) 3163254721Semaste { 3164254721Semaste ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime(); 3165254721Semaste if (objc_runtime != NULL) 3166254721Semaste { 3167254721Semaste ClangASTType parent_ast_type (m_ast, parent_qual_type); 3168254721Semaste child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str()); 3169254721Semaste } 3170254721Semaste } 3171254721Semaste 3172254721Semaste // Setting this to UINT32_MAX to make sure we don't compute it twice... 3173254721Semaste bit_offset = UINT32_MAX; 3174254721Semaste 3175254721Semaste if (child_byte_offset == LLDB_INVALID_IVAR_OFFSET) 3176254721Semaste { 3177254721Semaste bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx); 3178254721Semaste child_byte_offset = bit_offset / 8; 3179254721Semaste } 3180254721Semaste 3181254721Semaste // Note, the ObjC Ivar Byte offset is just that, it doesn't account for the bit offset 3182254721Semaste // of a bitfield within its containing object. So regardless of where we get the byte 3183254721Semaste // offset from, we still need to get the bit offset for bitfields from the layout. 3184254721Semaste 3185254721Semaste if (ClangASTContext::FieldIsBitfield (m_ast, ivar_decl, child_bitfield_bit_size)) 3186254721Semaste { 3187254721Semaste if (bit_offset == UINT32_MAX) 3188254721Semaste bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx); 3189254721Semaste 3190254721Semaste child_bitfield_bit_offset = bit_offset % 8; 3191254721Semaste } 3192254721Semaste return ClangASTType (m_ast, ivar_qual_type); 3193254721Semaste } 3194254721Semaste ++child_idx; 3195254721Semaste } 3196254721Semaste } 3197254721Semaste } 3198254721Semaste } 3199254721Semaste } 3200254721Semaste break; 3201254721Semaste 3202254721Semaste case clang::Type::ObjCObjectPointer: 3203254721Semaste if (idx_is_valid) 3204254721Semaste { 3205254721Semaste ClangASTType pointee_clang_type (GetPointeeType()); 3206254721Semaste 3207254721Semaste if (transparent_pointers && pointee_clang_type.IsAggregateType()) 3208254721Semaste { 3209254721Semaste child_is_deref_of_parent = false; 3210254721Semaste bool tmp_child_is_deref_of_parent = false; 3211254721Semaste return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3212254721Semaste parent_name, 3213254721Semaste idx, 3214254721Semaste transparent_pointers, 3215254721Semaste omit_empty_base_classes, 3216254721Semaste ignore_array_bounds, 3217254721Semaste child_name, 3218254721Semaste child_byte_size, 3219254721Semaste child_byte_offset, 3220254721Semaste child_bitfield_bit_size, 3221254721Semaste child_bitfield_bit_offset, 3222254721Semaste child_is_base_class, 3223254721Semaste tmp_child_is_deref_of_parent); 3224254721Semaste } 3225254721Semaste else 3226254721Semaste { 3227254721Semaste child_is_deref_of_parent = true; 3228254721Semaste if (parent_name) 3229254721Semaste { 3230254721Semaste child_name.assign(1, '*'); 3231254721Semaste child_name += parent_name; 3232254721Semaste } 3233254721Semaste 3234254721Semaste // We have a pointer to an simple type 3235254721Semaste if (idx == 0 && pointee_clang_type.GetCompleteType()) 3236254721Semaste { 3237254721Semaste child_byte_size = pointee_clang_type.GetByteSize(); 3238254721Semaste child_byte_offset = 0; 3239254721Semaste return pointee_clang_type; 3240254721Semaste } 3241254721Semaste } 3242254721Semaste } 3243254721Semaste break; 3244254721Semaste 3245254721Semaste case clang::Type::Vector: 3246254721Semaste case clang::Type::ExtVector: 3247254721Semaste if (idx_is_valid) 3248254721Semaste { 3249254721Semaste const VectorType *array = cast<VectorType>(parent_qual_type.getTypePtr()); 3250254721Semaste if (array) 3251254721Semaste { 3252254721Semaste ClangASTType element_type (m_ast, array->getElementType()); 3253254721Semaste if (element_type.GetCompleteType()) 3254254721Semaste { 3255254721Semaste char element_name[64]; 3256254721Semaste ::snprintf (element_name, sizeof (element_name), "[%zu]", idx); 3257254721Semaste child_name.assign(element_name); 3258254721Semaste child_byte_size = element_type.GetByteSize(); 3259254721Semaste child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; 3260254721Semaste return element_type; 3261254721Semaste } 3262254721Semaste } 3263254721Semaste } 3264254721Semaste break; 3265254721Semaste 3266254721Semaste case clang::Type::ConstantArray: 3267254721Semaste case clang::Type::IncompleteArray: 3268254721Semaste if (ignore_array_bounds || idx_is_valid) 3269254721Semaste { 3270254721Semaste const ArrayType *array = cast<ArrayType>(parent_qual_type.getTypePtr()); 3271254721Semaste if (array) 3272254721Semaste { 3273254721Semaste ClangASTType element_type (m_ast, array->getElementType()); 3274254721Semaste if (element_type.GetCompleteType()) 3275254721Semaste { 3276254721Semaste char element_name[64]; 3277254721Semaste ::snprintf (element_name, sizeof (element_name), "[%zu]", idx); 3278254721Semaste child_name.assign(element_name); 3279254721Semaste child_byte_size = element_type.GetByteSize(); 3280254721Semaste child_byte_offset = (int32_t)idx * (int32_t)child_byte_size; 3281254721Semaste return element_type; 3282254721Semaste } 3283254721Semaste } 3284254721Semaste } 3285254721Semaste break; 3286254721Semaste 3287254721Semaste 3288254721Semaste case clang::Type::Pointer: 3289254721Semaste if (idx_is_valid) 3290254721Semaste { 3291254721Semaste ClangASTType pointee_clang_type (GetPointeeType()); 3292254721Semaste 3293254721Semaste // Don't dereference "void *" pointers 3294254721Semaste if (pointee_clang_type.IsVoidType()) 3295254721Semaste return ClangASTType(); 3296254721Semaste 3297254721Semaste if (transparent_pointers && pointee_clang_type.IsAggregateType ()) 3298254721Semaste { 3299254721Semaste child_is_deref_of_parent = false; 3300254721Semaste bool tmp_child_is_deref_of_parent = false; 3301254721Semaste return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3302254721Semaste parent_name, 3303254721Semaste idx, 3304254721Semaste transparent_pointers, 3305254721Semaste omit_empty_base_classes, 3306254721Semaste ignore_array_bounds, 3307254721Semaste child_name, 3308254721Semaste child_byte_size, 3309254721Semaste child_byte_offset, 3310254721Semaste child_bitfield_bit_size, 3311254721Semaste child_bitfield_bit_offset, 3312254721Semaste child_is_base_class, 3313254721Semaste tmp_child_is_deref_of_parent); 3314254721Semaste } 3315254721Semaste else 3316254721Semaste { 3317254721Semaste child_is_deref_of_parent = true; 3318254721Semaste 3319254721Semaste if (parent_name) 3320254721Semaste { 3321254721Semaste child_name.assign(1, '*'); 3322254721Semaste child_name += parent_name; 3323254721Semaste } 3324254721Semaste 3325254721Semaste // We have a pointer to an simple type 3326254721Semaste if (idx == 0) 3327254721Semaste { 3328254721Semaste child_byte_size = pointee_clang_type.GetByteSize(); 3329254721Semaste child_byte_offset = 0; 3330254721Semaste return pointee_clang_type; 3331254721Semaste } 3332254721Semaste } 3333254721Semaste } 3334254721Semaste break; 3335254721Semaste 3336254721Semaste case clang::Type::LValueReference: 3337254721Semaste case clang::Type::RValueReference: 3338254721Semaste if (idx_is_valid) 3339254721Semaste { 3340254721Semaste const ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr()); 3341254721Semaste ClangASTType pointee_clang_type (m_ast, reference_type->getPointeeType()); 3342254721Semaste if (transparent_pointers && pointee_clang_type.IsAggregateType ()) 3343254721Semaste { 3344254721Semaste child_is_deref_of_parent = false; 3345254721Semaste bool tmp_child_is_deref_of_parent = false; 3346254721Semaste return pointee_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3347254721Semaste parent_name, 3348254721Semaste idx, 3349254721Semaste transparent_pointers, 3350254721Semaste omit_empty_base_classes, 3351254721Semaste ignore_array_bounds, 3352254721Semaste child_name, 3353254721Semaste child_byte_size, 3354254721Semaste child_byte_offset, 3355254721Semaste child_bitfield_bit_size, 3356254721Semaste child_bitfield_bit_offset, 3357254721Semaste child_is_base_class, 3358254721Semaste tmp_child_is_deref_of_parent); 3359254721Semaste } 3360254721Semaste else 3361254721Semaste { 3362254721Semaste if (parent_name) 3363254721Semaste { 3364254721Semaste child_name.assign(1, '&'); 3365254721Semaste child_name += parent_name; 3366254721Semaste } 3367254721Semaste 3368254721Semaste // We have a pointer to an simple type 3369254721Semaste if (idx == 0) 3370254721Semaste { 3371254721Semaste child_byte_size = pointee_clang_type.GetByteSize(); 3372254721Semaste child_byte_offset = 0; 3373254721Semaste return pointee_clang_type; 3374254721Semaste } 3375254721Semaste } 3376254721Semaste } 3377254721Semaste break; 3378254721Semaste 3379254721Semaste case clang::Type::Typedef: 3380254721Semaste { 3381254721Semaste ClangASTType typedefed_clang_type (m_ast, cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType()); 3382254721Semaste return typedefed_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3383254721Semaste parent_name, 3384254721Semaste idx, 3385254721Semaste transparent_pointers, 3386254721Semaste omit_empty_base_classes, 3387254721Semaste ignore_array_bounds, 3388254721Semaste child_name, 3389254721Semaste child_byte_size, 3390254721Semaste child_byte_offset, 3391254721Semaste child_bitfield_bit_size, 3392254721Semaste child_bitfield_bit_offset, 3393254721Semaste child_is_base_class, 3394254721Semaste child_is_deref_of_parent); 3395254721Semaste } 3396254721Semaste break; 3397254721Semaste 3398254721Semaste case clang::Type::Elaborated: 3399254721Semaste { 3400254721Semaste ClangASTType elaborated_clang_type (m_ast, cast<ElaboratedType>(parent_qual_type)->getNamedType()); 3401254721Semaste return elaborated_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3402254721Semaste parent_name, 3403254721Semaste idx, 3404254721Semaste transparent_pointers, 3405254721Semaste omit_empty_base_classes, 3406254721Semaste ignore_array_bounds, 3407254721Semaste child_name, 3408254721Semaste child_byte_size, 3409254721Semaste child_byte_offset, 3410254721Semaste child_bitfield_bit_size, 3411254721Semaste child_bitfield_bit_offset, 3412254721Semaste child_is_base_class, 3413254721Semaste child_is_deref_of_parent); 3414254721Semaste } 3415254721Semaste 3416254721Semaste case clang::Type::Paren: 3417254721Semaste { 3418254721Semaste ClangASTType paren_clang_type (m_ast, llvm::cast<clang::ParenType>(parent_qual_type)->desugar()); 3419254721Semaste return paren_clang_type.GetChildClangTypeAtIndex (exe_ctx, 3420254721Semaste parent_name, 3421254721Semaste idx, 3422254721Semaste transparent_pointers, 3423254721Semaste omit_empty_base_classes, 3424254721Semaste ignore_array_bounds, 3425254721Semaste child_name, 3426254721Semaste child_byte_size, 3427254721Semaste child_byte_offset, 3428254721Semaste child_bitfield_bit_size, 3429254721Semaste child_bitfield_bit_offset, 3430254721Semaste child_is_base_class, 3431254721Semaste child_is_deref_of_parent); 3432254721Semaste } 3433254721Semaste 3434254721Semaste 3435254721Semaste default: 3436254721Semaste break; 3437254721Semaste } 3438254721Semaste return ClangASTType(); 3439254721Semaste} 3440254721Semaste 3441254721Semastestatic inline bool 3442254721SemasteBaseSpecifierIsEmpty (const CXXBaseSpecifier *b) 3443254721Semaste{ 3444254721Semaste return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false; 3445254721Semaste} 3446254721Semaste 3447254721Semastestatic uint32_t 3448254721SemasteGetIndexForRecordBase 3449254721Semaste( 3450254721Semaste const RecordDecl *record_decl, 3451254721Semaste const CXXBaseSpecifier *base_spec, 3452254721Semaste bool omit_empty_base_classes 3453254721Semaste ) 3454254721Semaste{ 3455254721Semaste uint32_t child_idx = 0; 3456254721Semaste 3457254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3458254721Semaste 3459254721Semaste // const char *super_name = record_decl->getNameAsCString(); 3460254721Semaste // const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString(); 3461254721Semaste // printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name); 3462254721Semaste // 3463254721Semaste if (cxx_record_decl) 3464254721Semaste { 3465254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3466254721Semaste for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3467254721Semaste base_class != base_class_end; 3468254721Semaste ++base_class) 3469254721Semaste { 3470254721Semaste if (omit_empty_base_classes) 3471254721Semaste { 3472254721Semaste if (BaseSpecifierIsEmpty (base_class)) 3473254721Semaste continue; 3474254721Semaste } 3475254721Semaste 3476254721Semaste // printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name, 3477254721Semaste // child_idx, 3478254721Semaste // base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString()); 3479254721Semaste // 3480254721Semaste // 3481254721Semaste if (base_class == base_spec) 3482254721Semaste return child_idx; 3483254721Semaste ++child_idx; 3484254721Semaste } 3485254721Semaste } 3486254721Semaste 3487254721Semaste return UINT32_MAX; 3488254721Semaste} 3489254721Semaste 3490254721Semaste 3491254721Semastestatic uint32_t 3492254721SemasteGetIndexForRecordChild (const RecordDecl *record_decl, 3493254721Semaste NamedDecl *canonical_decl, 3494254721Semaste bool omit_empty_base_classes) 3495254721Semaste{ 3496254721Semaste uint32_t child_idx = ClangASTContext::GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl), 3497254721Semaste omit_empty_base_classes); 3498254721Semaste 3499254721Semaste RecordDecl::field_iterator field, field_end; 3500254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 3501254721Semaste field != field_end; 3502254721Semaste ++field, ++child_idx) 3503254721Semaste { 3504254721Semaste if (field->getCanonicalDecl() == canonical_decl) 3505254721Semaste return child_idx; 3506254721Semaste } 3507254721Semaste 3508254721Semaste return UINT32_MAX; 3509254721Semaste} 3510254721Semaste 3511254721Semaste// Look for a child member (doesn't include base classes, but it does include 3512254721Semaste// their members) in the type hierarchy. Returns an index path into "clang_type" 3513254721Semaste// on how to reach the appropriate member. 3514254721Semaste// 3515254721Semaste// class A 3516254721Semaste// { 3517254721Semaste// public: 3518254721Semaste// int m_a; 3519254721Semaste// int m_b; 3520254721Semaste// }; 3521254721Semaste// 3522254721Semaste// class B 3523254721Semaste// { 3524254721Semaste// }; 3525254721Semaste// 3526254721Semaste// class C : 3527254721Semaste// public B, 3528254721Semaste// public A 3529254721Semaste// { 3530254721Semaste// }; 3531254721Semaste// 3532254721Semaste// If we have a clang type that describes "class C", and we wanted to looked 3533254721Semaste// "m_b" in it: 3534254721Semaste// 3535254721Semaste// With omit_empty_base_classes == false we would get an integer array back with: 3536254721Semaste// { 1, 1 } 3537254721Semaste// The first index 1 is the child index for "class A" within class C 3538254721Semaste// The second index 1 is the child index for "m_b" within class A 3539254721Semaste// 3540254721Semaste// With omit_empty_base_classes == true we would get an integer array back with: 3541254721Semaste// { 0, 1 } 3542254721Semaste// 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) 3543254721Semaste// The second index 1 is the child index for "m_b" within class A 3544254721Semaste 3545254721Semastesize_t 3546254721SemasteClangASTType::GetIndexOfChildMemberWithName (const char *name, 3547254721Semaste bool omit_empty_base_classes, 3548254721Semaste std::vector<uint32_t>& child_indexes) const 3549254721Semaste{ 3550254721Semaste if (IsValid() && name && name[0]) 3551254721Semaste { 3552254721Semaste QualType qual_type(GetCanonicalQualType()); 3553254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3554254721Semaste switch (type_class) 3555254721Semaste { 3556254721Semaste case clang::Type::Record: 3557254721Semaste if (GetCompleteType ()) 3558254721Semaste { 3559254721Semaste const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 3560254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 3561254721Semaste 3562254721Semaste assert(record_decl); 3563254721Semaste uint32_t child_idx = 0; 3564254721Semaste 3565254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3566254721Semaste 3567254721Semaste // Try and find a field that matches NAME 3568254721Semaste RecordDecl::field_iterator field, field_end; 3569254721Semaste StringRef name_sref(name); 3570254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 3571254721Semaste field != field_end; 3572254721Semaste ++field, ++child_idx) 3573254721Semaste { 3574263363Semaste llvm::StringRef field_name = field->getName(); 3575263363Semaste if (field_name.empty()) 3576254721Semaste { 3577263363Semaste ClangASTType field_type(m_ast,field->getType()); 3578263363Semaste child_indexes.push_back(child_idx); 3579263363Semaste if (field_type.GetIndexOfChildMemberWithName(name, omit_empty_base_classes, child_indexes)) 3580263363Semaste return child_indexes.size(); 3581263363Semaste child_indexes.pop_back(); 3582263363Semaste 3583263363Semaste } 3584263363Semaste else if (field_name.equals (name_sref)) 3585263363Semaste { 3586254721Semaste // We have to add on the number of base classes to this index! 3587254721Semaste child_indexes.push_back (child_idx + ClangASTContext::GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes)); 3588254721Semaste return child_indexes.size(); 3589254721Semaste } 3590254721Semaste } 3591254721Semaste 3592254721Semaste if (cxx_record_decl) 3593254721Semaste { 3594254721Semaste const RecordDecl *parent_record_decl = cxx_record_decl; 3595254721Semaste 3596254721Semaste //printf ("parent = %s\n", parent_record_decl->getNameAsCString()); 3597254721Semaste 3598254721Semaste //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl(); 3599254721Semaste // Didn't find things easily, lets let clang do its thang... 3600254721Semaste IdentifierInfo & ident_ref = m_ast->Idents.get(name_sref); 3601254721Semaste DeclarationName decl_name(&ident_ref); 3602254721Semaste 3603254721Semaste CXXBasePaths paths; 3604254721Semaste if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember, 3605254721Semaste decl_name.getAsOpaquePtr(), 3606254721Semaste paths)) 3607254721Semaste { 3608254721Semaste CXXBasePaths::const_paths_iterator path, path_end = paths.end(); 3609254721Semaste for (path = paths.begin(); path != path_end; ++path) 3610254721Semaste { 3611254721Semaste const size_t num_path_elements = path->size(); 3612254721Semaste for (size_t e=0; e<num_path_elements; ++e) 3613254721Semaste { 3614254721Semaste CXXBasePathElement elem = (*path)[e]; 3615254721Semaste 3616254721Semaste child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes); 3617254721Semaste if (child_idx == UINT32_MAX) 3618254721Semaste { 3619254721Semaste child_indexes.clear(); 3620254721Semaste return 0; 3621254721Semaste } 3622254721Semaste else 3623254721Semaste { 3624254721Semaste child_indexes.push_back (child_idx); 3625254721Semaste parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl()); 3626254721Semaste } 3627254721Semaste } 3628254721Semaste for (NamedDecl *path_decl : path->Decls) 3629254721Semaste { 3630254721Semaste child_idx = GetIndexForRecordChild (parent_record_decl, path_decl, omit_empty_base_classes); 3631254721Semaste if (child_idx == UINT32_MAX) 3632254721Semaste { 3633254721Semaste child_indexes.clear(); 3634254721Semaste return 0; 3635254721Semaste } 3636254721Semaste else 3637254721Semaste { 3638254721Semaste child_indexes.push_back (child_idx); 3639254721Semaste } 3640254721Semaste } 3641254721Semaste } 3642254721Semaste return child_indexes.size(); 3643254721Semaste } 3644254721Semaste } 3645254721Semaste 3646254721Semaste } 3647254721Semaste break; 3648254721Semaste 3649254721Semaste case clang::Type::ObjCObject: 3650254721Semaste case clang::Type::ObjCInterface: 3651254721Semaste if (GetCompleteType ()) 3652254721Semaste { 3653254721Semaste StringRef name_sref(name); 3654254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 3655254721Semaste assert (objc_class_type); 3656254721Semaste if (objc_class_type) 3657254721Semaste { 3658254721Semaste uint32_t child_idx = 0; 3659254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3660254721Semaste 3661254721Semaste if (class_interface_decl) 3662254721Semaste { 3663254721Semaste ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 3664254721Semaste ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3665254721Semaste 3666254721Semaste for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) 3667254721Semaste { 3668254721Semaste const ObjCIvarDecl* ivar_decl = *ivar_pos; 3669254721Semaste 3670254721Semaste if (ivar_decl->getName().equals (name_sref)) 3671254721Semaste { 3672254721Semaste if ((!omit_empty_base_classes && superclass_interface_decl) || 3673254721Semaste ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true))) 3674254721Semaste ++child_idx; 3675254721Semaste 3676254721Semaste child_indexes.push_back (child_idx); 3677254721Semaste return child_indexes.size(); 3678254721Semaste } 3679254721Semaste } 3680254721Semaste 3681254721Semaste if (superclass_interface_decl) 3682254721Semaste { 3683254721Semaste // The super class index is always zero for ObjC classes, 3684254721Semaste // so we push it onto the child indexes in case we find 3685254721Semaste // an ivar in our superclass... 3686254721Semaste child_indexes.push_back (0); 3687254721Semaste 3688254721Semaste ClangASTType superclass_clang_type (m_ast, m_ast->getObjCInterfaceType(superclass_interface_decl)); 3689254721Semaste if (superclass_clang_type.GetIndexOfChildMemberWithName (name, 3690254721Semaste omit_empty_base_classes, 3691254721Semaste child_indexes)) 3692254721Semaste { 3693254721Semaste // We did find an ivar in a superclass so just 3694254721Semaste // return the results! 3695254721Semaste return child_indexes.size(); 3696254721Semaste } 3697254721Semaste 3698254721Semaste // We didn't find an ivar matching "name" in our 3699254721Semaste // superclass, pop the superclass zero index that 3700254721Semaste // we pushed on above. 3701254721Semaste child_indexes.pop_back(); 3702254721Semaste } 3703254721Semaste } 3704254721Semaste } 3705254721Semaste } 3706254721Semaste break; 3707254721Semaste 3708254721Semaste case clang::Type::ObjCObjectPointer: 3709254721Semaste { 3710254721Semaste ClangASTType objc_object_clang_type (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()); 3711254721Semaste return objc_object_clang_type.GetIndexOfChildMemberWithName (name, 3712254721Semaste omit_empty_base_classes, 3713254721Semaste child_indexes); 3714254721Semaste } 3715254721Semaste break; 3716254721Semaste 3717254721Semaste 3718254721Semaste case clang::Type::ConstantArray: 3719254721Semaste { 3720254721Semaste // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); 3721254721Semaste // const uint64_t element_count = array->getSize().getLimitedValue(); 3722254721Semaste // 3723254721Semaste // if (idx < element_count) 3724254721Semaste // { 3725254721Semaste // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); 3726254721Semaste // 3727254721Semaste // char element_name[32]; 3728254721Semaste // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx); 3729254721Semaste // 3730254721Semaste // child_name.assign(element_name); 3731254721Semaste // assert(field_type_info.first % 8 == 0); 3732254721Semaste // child_byte_size = field_type_info.first / 8; 3733254721Semaste // child_byte_offset = idx * child_byte_size; 3734254721Semaste // return array->getElementType().getAsOpaquePtr(); 3735254721Semaste // } 3736254721Semaste } 3737254721Semaste break; 3738254721Semaste 3739254721Semaste // case clang::Type::MemberPointerType: 3740254721Semaste // { 3741254721Semaste // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr()); 3742254721Semaste // QualType pointee_type = mem_ptr_type->getPointeeType(); 3743254721Semaste // 3744254721Semaste // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 3745254721Semaste // { 3746254721Semaste // return GetIndexOfChildWithName (ast, 3747254721Semaste // mem_ptr_type->getPointeeType().getAsOpaquePtr(), 3748254721Semaste // name); 3749254721Semaste // } 3750254721Semaste // } 3751254721Semaste // break; 3752254721Semaste // 3753254721Semaste case clang::Type::LValueReference: 3754254721Semaste case clang::Type::RValueReference: 3755254721Semaste { 3756254721Semaste const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 3757254721Semaste QualType pointee_type(reference_type->getPointeeType()); 3758254721Semaste ClangASTType pointee_clang_type (m_ast, pointee_type); 3759254721Semaste 3760254721Semaste if (pointee_clang_type.IsAggregateType ()) 3761254721Semaste { 3762254721Semaste return pointee_clang_type.GetIndexOfChildMemberWithName (name, 3763254721Semaste omit_empty_base_classes, 3764254721Semaste child_indexes); 3765254721Semaste } 3766254721Semaste } 3767254721Semaste break; 3768254721Semaste 3769254721Semaste case clang::Type::Pointer: 3770254721Semaste { 3771254721Semaste ClangASTType pointee_clang_type (GetPointeeType()); 3772254721Semaste 3773254721Semaste if (pointee_clang_type.IsAggregateType ()) 3774254721Semaste { 3775254721Semaste return pointee_clang_type.GetIndexOfChildMemberWithName (name, 3776254721Semaste omit_empty_base_classes, 3777254721Semaste child_indexes); 3778254721Semaste } 3779254721Semaste } 3780254721Semaste break; 3781254721Semaste 3782254721Semaste case clang::Type::Typedef: 3783254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildMemberWithName (name, 3784254721Semaste omit_empty_base_classes, 3785254721Semaste child_indexes); 3786254721Semaste 3787254721Semaste case clang::Type::Elaborated: 3788254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildMemberWithName (name, 3789254721Semaste omit_empty_base_classes, 3790254721Semaste child_indexes); 3791254721Semaste 3792254721Semaste case clang::Type::Paren: 3793254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildMemberWithName (name, 3794254721Semaste omit_empty_base_classes, 3795254721Semaste child_indexes); 3796254721Semaste 3797254721Semaste default: 3798254721Semaste break; 3799254721Semaste } 3800254721Semaste } 3801254721Semaste return 0; 3802254721Semaste} 3803254721Semaste 3804254721Semaste 3805254721Semaste// Get the index of the child of "clang_type" whose name matches. This function 3806254721Semaste// doesn't descend into the children, but only looks one level deep and name 3807254721Semaste// matches can include base class names. 3808254721Semaste 3809254721Semasteuint32_t 3810254721SemasteClangASTType::GetIndexOfChildWithName (const char *name, bool omit_empty_base_classes) const 3811254721Semaste{ 3812254721Semaste if (IsValid() && name && name[0]) 3813254721Semaste { 3814254721Semaste QualType qual_type(GetCanonicalQualType()); 3815254721Semaste 3816254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 3817254721Semaste 3818254721Semaste switch (type_class) 3819254721Semaste { 3820254721Semaste case clang::Type::Record: 3821254721Semaste if (GetCompleteType ()) 3822254721Semaste { 3823254721Semaste const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 3824254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 3825254721Semaste 3826254721Semaste assert(record_decl); 3827254721Semaste uint32_t child_idx = 0; 3828254721Semaste 3829254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 3830254721Semaste 3831254721Semaste if (cxx_record_decl) 3832254721Semaste { 3833254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 3834254721Semaste for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 3835254721Semaste base_class != base_class_end; 3836254721Semaste ++base_class) 3837254721Semaste { 3838254721Semaste // Skip empty base classes 3839254721Semaste CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 3840254721Semaste if (omit_empty_base_classes && ClangASTContext::RecordHasFields(base_class_decl) == false) 3841254721Semaste continue; 3842254721Semaste 3843254721Semaste ClangASTType base_class_clang_type (m_ast, base_class->getType()); 3844263363Semaste std::string base_class_type_name (base_class_clang_type.GetTypeName().AsCString("")); 3845254721Semaste if (base_class_type_name.compare (name) == 0) 3846254721Semaste return child_idx; 3847254721Semaste ++child_idx; 3848254721Semaste } 3849254721Semaste } 3850254721Semaste 3851254721Semaste // Try and find a field that matches NAME 3852254721Semaste RecordDecl::field_iterator field, field_end; 3853254721Semaste StringRef name_sref(name); 3854254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(); 3855254721Semaste field != field_end; 3856254721Semaste ++field, ++child_idx) 3857254721Semaste { 3858254721Semaste if (field->getName().equals (name_sref)) 3859254721Semaste return child_idx; 3860254721Semaste } 3861254721Semaste 3862254721Semaste } 3863254721Semaste break; 3864254721Semaste 3865254721Semaste case clang::Type::ObjCObject: 3866254721Semaste case clang::Type::ObjCInterface: 3867254721Semaste if (GetCompleteType()) 3868254721Semaste { 3869254721Semaste StringRef name_sref(name); 3870254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 3871254721Semaste assert (objc_class_type); 3872254721Semaste if (objc_class_type) 3873254721Semaste { 3874254721Semaste uint32_t child_idx = 0; 3875254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 3876254721Semaste 3877254721Semaste if (class_interface_decl) 3878254721Semaste { 3879254721Semaste ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end(); 3880254721Semaste ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass(); 3881254721Semaste 3882254721Semaste for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx) 3883254721Semaste { 3884254721Semaste const ObjCIvarDecl* ivar_decl = *ivar_pos; 3885254721Semaste 3886254721Semaste if (ivar_decl->getName().equals (name_sref)) 3887254721Semaste { 3888254721Semaste if ((!omit_empty_base_classes && superclass_interface_decl) || 3889254721Semaste ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true))) 3890254721Semaste ++child_idx; 3891254721Semaste 3892254721Semaste return child_idx; 3893254721Semaste } 3894254721Semaste } 3895254721Semaste 3896254721Semaste if (superclass_interface_decl) 3897254721Semaste { 3898254721Semaste if (superclass_interface_decl->getName().equals (name_sref)) 3899254721Semaste return 0; 3900254721Semaste } 3901254721Semaste } 3902254721Semaste } 3903254721Semaste } 3904254721Semaste break; 3905254721Semaste 3906254721Semaste case clang::Type::ObjCObjectPointer: 3907254721Semaste { 3908254721Semaste ClangASTType pointee_clang_type (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()); 3909254721Semaste return pointee_clang_type.GetIndexOfChildWithName (name, omit_empty_base_classes); 3910254721Semaste } 3911254721Semaste break; 3912254721Semaste 3913254721Semaste case clang::Type::ConstantArray: 3914254721Semaste { 3915254721Semaste // const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr()); 3916254721Semaste // const uint64_t element_count = array->getSize().getLimitedValue(); 3917254721Semaste // 3918254721Semaste // if (idx < element_count) 3919254721Semaste // { 3920254721Semaste // std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType()); 3921254721Semaste // 3922254721Semaste // char element_name[32]; 3923254721Semaste // ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx); 3924254721Semaste // 3925254721Semaste // child_name.assign(element_name); 3926254721Semaste // assert(field_type_info.first % 8 == 0); 3927254721Semaste // child_byte_size = field_type_info.first / 8; 3928254721Semaste // child_byte_offset = idx * child_byte_size; 3929254721Semaste // return array->getElementType().getAsOpaquePtr(); 3930254721Semaste // } 3931254721Semaste } 3932254721Semaste break; 3933254721Semaste 3934254721Semaste // case clang::Type::MemberPointerType: 3935254721Semaste // { 3936254721Semaste // MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr()); 3937254721Semaste // QualType pointee_type = mem_ptr_type->getPointeeType(); 3938254721Semaste // 3939254721Semaste // if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr())) 3940254721Semaste // { 3941254721Semaste // return GetIndexOfChildWithName (ast, 3942254721Semaste // mem_ptr_type->getPointeeType().getAsOpaquePtr(), 3943254721Semaste // name); 3944254721Semaste // } 3945254721Semaste // } 3946254721Semaste // break; 3947254721Semaste // 3948254721Semaste case clang::Type::LValueReference: 3949254721Semaste case clang::Type::RValueReference: 3950254721Semaste { 3951254721Semaste const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr()); 3952254721Semaste ClangASTType pointee_type (m_ast, reference_type->getPointeeType()); 3953254721Semaste 3954254721Semaste if (pointee_type.IsAggregateType ()) 3955254721Semaste { 3956254721Semaste return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes); 3957254721Semaste } 3958254721Semaste } 3959254721Semaste break; 3960254721Semaste 3961254721Semaste case clang::Type::Pointer: 3962254721Semaste { 3963254721Semaste const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr()); 3964254721Semaste ClangASTType pointee_type (m_ast, pointer_type->getPointeeType()); 3965254721Semaste 3966254721Semaste if (pointee_type.IsAggregateType ()) 3967254721Semaste { 3968254721Semaste return pointee_type.GetIndexOfChildWithName (name, omit_empty_base_classes); 3969254721Semaste } 3970254721Semaste else 3971254721Semaste { 3972254721Semaste // if (parent_name) 3973254721Semaste // { 3974254721Semaste // child_name.assign(1, '*'); 3975254721Semaste // child_name += parent_name; 3976254721Semaste // } 3977254721Semaste // 3978254721Semaste // // We have a pointer to an simple type 3979254721Semaste // if (idx == 0) 3980254721Semaste // { 3981254721Semaste // std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type); 3982254721Semaste // assert(clang_type_info.first % 8 == 0); 3983254721Semaste // child_byte_size = clang_type_info.first / 8; 3984254721Semaste // child_byte_offset = 0; 3985254721Semaste // return pointee_type.getAsOpaquePtr(); 3986254721Semaste // } 3987254721Semaste } 3988254721Semaste } 3989254721Semaste break; 3990254721Semaste 3991254721Semaste case clang::Type::Elaborated: 3992254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetIndexOfChildWithName (name, omit_empty_base_classes); 3993254721Semaste 3994254721Semaste case clang::Type::Paren: 3995254721Semaste return ClangASTType (m_ast, cast<clang::ParenType>(qual_type)->desugar()).GetIndexOfChildWithName (name, omit_empty_base_classes); 3996254721Semaste 3997254721Semaste case clang::Type::Typedef: 3998254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetIndexOfChildWithName (name, omit_empty_base_classes); 3999254721Semaste 4000254721Semaste default: 4001254721Semaste break; 4002254721Semaste } 4003254721Semaste } 4004254721Semaste return UINT32_MAX; 4005254721Semaste} 4006254721Semaste 4007254721Semaste 4008254721Semastesize_t 4009254721SemasteClangASTType::GetNumTemplateArguments () const 4010254721Semaste{ 4011254721Semaste if (IsValid()) 4012254721Semaste { 4013254721Semaste QualType qual_type (GetCanonicalQualType()); 4014254721Semaste 4015254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 4016254721Semaste switch (type_class) 4017254721Semaste { 4018254721Semaste case clang::Type::Record: 4019254721Semaste if (GetCompleteType ()) 4020254721Semaste { 4021254721Semaste const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 4022254721Semaste if (cxx_record_decl) 4023254721Semaste { 4024254721Semaste const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl); 4025254721Semaste if (template_decl) 4026254721Semaste return template_decl->getTemplateArgs().size(); 4027254721Semaste } 4028254721Semaste } 4029254721Semaste break; 4030254721Semaste 4031254721Semaste case clang::Type::Typedef: 4032254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetNumTemplateArguments(); 4033254721Semaste 4034254721Semaste case clang::Type::Elaborated: 4035254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetNumTemplateArguments(); 4036254721Semaste 4037254721Semaste case clang::Type::Paren: 4038254721Semaste return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetNumTemplateArguments(); 4039254721Semaste 4040254721Semaste default: 4041254721Semaste break; 4042254721Semaste } 4043254721Semaste } 4044254721Semaste return 0; 4045254721Semaste} 4046254721Semaste 4047254721SemasteClangASTType 4048254721SemasteClangASTType::GetTemplateArgument (size_t arg_idx, lldb::TemplateArgumentKind &kind) const 4049254721Semaste{ 4050254721Semaste if (IsValid()) 4051254721Semaste { 4052254721Semaste QualType qual_type (GetCanonicalQualType()); 4053254721Semaste 4054254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 4055254721Semaste switch (type_class) 4056254721Semaste { 4057254721Semaste case clang::Type::Record: 4058254721Semaste if (GetCompleteType ()) 4059254721Semaste { 4060254721Semaste const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 4061254721Semaste if (cxx_record_decl) 4062254721Semaste { 4063254721Semaste const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl); 4064254721Semaste if (template_decl && arg_idx < template_decl->getTemplateArgs().size()) 4065254721Semaste { 4066254721Semaste const TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx]; 4067254721Semaste switch (template_arg.getKind()) 4068254721Semaste { 4069254721Semaste case clang::TemplateArgument::Null: 4070254721Semaste kind = eTemplateArgumentKindNull; 4071254721Semaste return ClangASTType(); 4072254721Semaste 4073254721Semaste case clang::TemplateArgument::Type: 4074254721Semaste kind = eTemplateArgumentKindType; 4075254721Semaste return ClangASTType(m_ast, template_arg.getAsType()); 4076254721Semaste 4077254721Semaste case clang::TemplateArgument::Declaration: 4078254721Semaste kind = eTemplateArgumentKindDeclaration; 4079254721Semaste return ClangASTType(); 4080254721Semaste 4081254721Semaste case clang::TemplateArgument::Integral: 4082254721Semaste kind = eTemplateArgumentKindIntegral; 4083254721Semaste return ClangASTType(m_ast, template_arg.getIntegralType()); 4084254721Semaste 4085254721Semaste case clang::TemplateArgument::Template: 4086254721Semaste kind = eTemplateArgumentKindTemplate; 4087254721Semaste return ClangASTType(); 4088254721Semaste 4089254721Semaste case clang::TemplateArgument::TemplateExpansion: 4090254721Semaste kind = eTemplateArgumentKindTemplateExpansion; 4091254721Semaste return ClangASTType(); 4092254721Semaste 4093254721Semaste case clang::TemplateArgument::Expression: 4094254721Semaste kind = eTemplateArgumentKindExpression; 4095254721Semaste return ClangASTType(); 4096254721Semaste 4097254721Semaste case clang::TemplateArgument::Pack: 4098254721Semaste kind = eTemplateArgumentKindPack; 4099254721Semaste return ClangASTType(); 4100254721Semaste 4101254721Semaste default: 4102254721Semaste assert (!"Unhandled TemplateArgument::ArgKind"); 4103254721Semaste break; 4104254721Semaste } 4105254721Semaste } 4106254721Semaste } 4107254721Semaste } 4108254721Semaste break; 4109254721Semaste 4110254721Semaste case clang::Type::Typedef: 4111254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetTemplateArgument (arg_idx, kind); 4112254721Semaste 4113254721Semaste case clang::Type::Elaborated: 4114254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetTemplateArgument (arg_idx, kind); 4115254721Semaste 4116254721Semaste case clang::Type::Paren: 4117254721Semaste return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetTemplateArgument (arg_idx, kind); 4118254721Semaste 4119254721Semaste default: 4120254721Semaste break; 4121254721Semaste } 4122254721Semaste } 4123254721Semaste kind = eTemplateArgumentKindNull; 4124254721Semaste return ClangASTType (); 4125254721Semaste} 4126254721Semaste 4127254721Semastestatic bool 4128254721SemasteIsOperator (const char *name, OverloadedOperatorKind &op_kind) 4129254721Semaste{ 4130254721Semaste if (name == NULL || name[0] == '\0') 4131254721Semaste return false; 4132254721Semaste 4133254721Semaste#define OPERATOR_PREFIX "operator" 4134254721Semaste#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1) 4135254721Semaste 4136254721Semaste const char *post_op_name = NULL; 4137254721Semaste 4138254721Semaste bool no_space = true; 4139254721Semaste 4140254721Semaste if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH)) 4141254721Semaste return false; 4142254721Semaste 4143254721Semaste post_op_name = name + OPERATOR_PREFIX_LENGTH; 4144254721Semaste 4145254721Semaste if (post_op_name[0] == ' ') 4146254721Semaste { 4147254721Semaste post_op_name++; 4148254721Semaste no_space = false; 4149254721Semaste } 4150254721Semaste 4151254721Semaste#undef OPERATOR_PREFIX 4152254721Semaste#undef OPERATOR_PREFIX_LENGTH 4153254721Semaste 4154254721Semaste // This is an operator, set the overloaded operator kind to invalid 4155254721Semaste // in case this is a conversion operator... 4156254721Semaste op_kind = NUM_OVERLOADED_OPERATORS; 4157254721Semaste 4158254721Semaste switch (post_op_name[0]) 4159254721Semaste { 4160254721Semaste default: 4161254721Semaste if (no_space) 4162254721Semaste return false; 4163254721Semaste break; 4164254721Semaste case 'n': 4165254721Semaste if (no_space) 4166254721Semaste return false; 4167254721Semaste if (strcmp (post_op_name, "new") == 0) 4168254721Semaste op_kind = OO_New; 4169254721Semaste else if (strcmp (post_op_name, "new[]") == 0) 4170254721Semaste op_kind = OO_Array_New; 4171254721Semaste break; 4172254721Semaste 4173254721Semaste case 'd': 4174254721Semaste if (no_space) 4175254721Semaste return false; 4176254721Semaste if (strcmp (post_op_name, "delete") == 0) 4177254721Semaste op_kind = OO_Delete; 4178254721Semaste else if (strcmp (post_op_name, "delete[]") == 0) 4179254721Semaste op_kind = OO_Array_Delete; 4180254721Semaste break; 4181254721Semaste 4182254721Semaste case '+': 4183254721Semaste if (post_op_name[1] == '\0') 4184254721Semaste op_kind = OO_Plus; 4185254721Semaste else if (post_op_name[2] == '\0') 4186254721Semaste { 4187254721Semaste if (post_op_name[1] == '=') 4188254721Semaste op_kind = OO_PlusEqual; 4189254721Semaste else if (post_op_name[1] == '+') 4190254721Semaste op_kind = OO_PlusPlus; 4191254721Semaste } 4192254721Semaste break; 4193254721Semaste 4194254721Semaste case '-': 4195254721Semaste if (post_op_name[1] == '\0') 4196254721Semaste op_kind = OO_Minus; 4197254721Semaste else if (post_op_name[2] == '\0') 4198254721Semaste { 4199254721Semaste switch (post_op_name[1]) 4200254721Semaste { 4201254721Semaste case '=': op_kind = OO_MinusEqual; break; 4202254721Semaste case '-': op_kind = OO_MinusMinus; break; 4203254721Semaste case '>': op_kind = OO_Arrow; break; 4204254721Semaste } 4205254721Semaste } 4206254721Semaste else if (post_op_name[3] == '\0') 4207254721Semaste { 4208254721Semaste if (post_op_name[2] == '*') 4209254721Semaste op_kind = OO_ArrowStar; break; 4210254721Semaste } 4211254721Semaste break; 4212254721Semaste 4213254721Semaste case '*': 4214254721Semaste if (post_op_name[1] == '\0') 4215254721Semaste op_kind = OO_Star; 4216254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4217254721Semaste op_kind = OO_StarEqual; 4218254721Semaste break; 4219254721Semaste 4220254721Semaste case '/': 4221254721Semaste if (post_op_name[1] == '\0') 4222254721Semaste op_kind = OO_Slash; 4223254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4224254721Semaste op_kind = OO_SlashEqual; 4225254721Semaste break; 4226254721Semaste 4227254721Semaste case '%': 4228254721Semaste if (post_op_name[1] == '\0') 4229254721Semaste op_kind = OO_Percent; 4230254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4231254721Semaste op_kind = OO_PercentEqual; 4232254721Semaste break; 4233254721Semaste 4234254721Semaste 4235254721Semaste case '^': 4236254721Semaste if (post_op_name[1] == '\0') 4237254721Semaste op_kind = OO_Caret; 4238254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4239254721Semaste op_kind = OO_CaretEqual; 4240254721Semaste break; 4241254721Semaste 4242254721Semaste case '&': 4243254721Semaste if (post_op_name[1] == '\0') 4244254721Semaste op_kind = OO_Amp; 4245254721Semaste else if (post_op_name[2] == '\0') 4246254721Semaste { 4247254721Semaste switch (post_op_name[1]) 4248254721Semaste { 4249254721Semaste case '=': op_kind = OO_AmpEqual; break; 4250254721Semaste case '&': op_kind = OO_AmpAmp; break; 4251254721Semaste } 4252254721Semaste } 4253254721Semaste break; 4254254721Semaste 4255254721Semaste case '|': 4256254721Semaste if (post_op_name[1] == '\0') 4257254721Semaste op_kind = OO_Pipe; 4258254721Semaste else if (post_op_name[2] == '\0') 4259254721Semaste { 4260254721Semaste switch (post_op_name[1]) 4261254721Semaste { 4262254721Semaste case '=': op_kind = OO_PipeEqual; break; 4263254721Semaste case '|': op_kind = OO_PipePipe; break; 4264254721Semaste } 4265254721Semaste } 4266254721Semaste break; 4267254721Semaste 4268254721Semaste case '~': 4269254721Semaste if (post_op_name[1] == '\0') 4270254721Semaste op_kind = OO_Tilde; 4271254721Semaste break; 4272254721Semaste 4273254721Semaste case '!': 4274254721Semaste if (post_op_name[1] == '\0') 4275254721Semaste op_kind = OO_Exclaim; 4276254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4277254721Semaste op_kind = OO_ExclaimEqual; 4278254721Semaste break; 4279254721Semaste 4280254721Semaste case '=': 4281254721Semaste if (post_op_name[1] == '\0') 4282254721Semaste op_kind = OO_Equal; 4283254721Semaste else if (post_op_name[1] == '=' && post_op_name[2] == '\0') 4284254721Semaste op_kind = OO_EqualEqual; 4285254721Semaste break; 4286254721Semaste 4287254721Semaste case '<': 4288254721Semaste if (post_op_name[1] == '\0') 4289254721Semaste op_kind = OO_Less; 4290254721Semaste else if (post_op_name[2] == '\0') 4291254721Semaste { 4292254721Semaste switch (post_op_name[1]) 4293254721Semaste { 4294254721Semaste case '<': op_kind = OO_LessLess; break; 4295254721Semaste case '=': op_kind = OO_LessEqual; break; 4296254721Semaste } 4297254721Semaste } 4298254721Semaste else if (post_op_name[3] == '\0') 4299254721Semaste { 4300254721Semaste if (post_op_name[2] == '=') 4301254721Semaste op_kind = OO_LessLessEqual; 4302254721Semaste } 4303254721Semaste break; 4304254721Semaste 4305254721Semaste case '>': 4306254721Semaste if (post_op_name[1] == '\0') 4307254721Semaste op_kind = OO_Greater; 4308254721Semaste else if (post_op_name[2] == '\0') 4309254721Semaste { 4310254721Semaste switch (post_op_name[1]) 4311254721Semaste { 4312254721Semaste case '>': op_kind = OO_GreaterGreater; break; 4313254721Semaste case '=': op_kind = OO_GreaterEqual; break; 4314254721Semaste } 4315254721Semaste } 4316254721Semaste else if (post_op_name[1] == '>' && 4317254721Semaste post_op_name[2] == '=' && 4318254721Semaste post_op_name[3] == '\0') 4319254721Semaste { 4320254721Semaste op_kind = OO_GreaterGreaterEqual; 4321254721Semaste } 4322254721Semaste break; 4323254721Semaste 4324254721Semaste case ',': 4325254721Semaste if (post_op_name[1] == '\0') 4326254721Semaste op_kind = OO_Comma; 4327254721Semaste break; 4328254721Semaste 4329254721Semaste case '(': 4330254721Semaste if (post_op_name[1] == ')' && post_op_name[2] == '\0') 4331254721Semaste op_kind = OO_Call; 4332254721Semaste break; 4333254721Semaste 4334254721Semaste case '[': 4335254721Semaste if (post_op_name[1] == ']' && post_op_name[2] == '\0') 4336254721Semaste op_kind = OO_Subscript; 4337254721Semaste break; 4338254721Semaste } 4339254721Semaste 4340254721Semaste return true; 4341254721Semaste} 4342254721Semaste 4343254721Semastestatic inline bool 4344254721Semastecheck_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params) 4345254721Semaste{ 4346254721Semaste // Special-case call since it can take any number of operands 4347254721Semaste if(op_kind == OO_Call) 4348254721Semaste return true; 4349254721Semaste 4350254721Semaste // The parameter count doens't include "this" 4351254721Semaste if (num_params == 0) 4352254721Semaste return unary; 4353254721Semaste if (num_params == 1) 4354254721Semaste return binary; 4355254721Semaste else 4356254721Semaste return false; 4357254721Semaste} 4358254721Semaste 4359254721Semasteclang::RecordDecl * 4360254721SemasteClangASTType::GetAsRecordDecl () const 4361254721Semaste{ 4362254721Semaste const RecordType *record_type = dyn_cast<RecordType>(GetCanonicalQualType()); 4363254721Semaste if (record_type) 4364254721Semaste return record_type->getDecl(); 4365254721Semaste return NULL; 4366254721Semaste} 4367254721Semaste 4368254721Semasteclang::CXXRecordDecl * 4369254721SemasteClangASTType::GetAsCXXRecordDecl () const 4370254721Semaste{ 4371254721Semaste return GetCanonicalQualType()->getAsCXXRecordDecl(); 4372254721Semaste} 4373254721Semaste 4374254721SemasteObjCInterfaceDecl * 4375254721SemasteClangASTType::GetAsObjCInterfaceDecl () const 4376254721Semaste{ 4377254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(GetCanonicalQualType()); 4378254721Semaste if (objc_class_type) 4379254721Semaste return objc_class_type->getInterface(); 4380254721Semaste return NULL; 4381254721Semaste} 4382254721Semaste 4383254721Semasteclang::FieldDecl * 4384254721SemasteClangASTType::AddFieldToRecordType (const char *name, 4385254721Semaste const ClangASTType &field_clang_type, 4386254721Semaste AccessType access, 4387254721Semaste uint32_t bitfield_bit_size) 4388254721Semaste{ 4389254721Semaste if (!IsValid() || !field_clang_type.IsValid()) 4390254721Semaste return NULL; 4391254721Semaste 4392254721Semaste FieldDecl *field = NULL; 4393254721Semaste 4394254721Semaste clang::Expr *bit_width = NULL; 4395254721Semaste if (bitfield_bit_size != 0) 4396254721Semaste { 4397254721Semaste APInt bitfield_bit_size_apint(m_ast->getTypeSize(m_ast->IntTy), bitfield_bit_size); 4398254721Semaste bit_width = new (*m_ast)IntegerLiteral (*m_ast, bitfield_bit_size_apint, m_ast->IntTy, SourceLocation()); 4399254721Semaste } 4400254721Semaste 4401254721Semaste RecordDecl *record_decl = GetAsRecordDecl (); 4402254721Semaste if (record_decl) 4403254721Semaste { 4404254721Semaste field = FieldDecl::Create (*m_ast, 4405254721Semaste record_decl, 4406254721Semaste SourceLocation(), 4407254721Semaste SourceLocation(), 4408254721Semaste name ? &m_ast->Idents.get(name) : NULL, // Identifier 4409254721Semaste field_clang_type.GetQualType(), // Field type 4410254721Semaste NULL, // TInfo * 4411254721Semaste bit_width, // BitWidth 4412254721Semaste false, // Mutable 4413254721Semaste ICIS_NoInit); // HasInit 4414254721Semaste 4415254721Semaste if (!name) 4416254721Semaste { 4417254721Semaste // Determine whether this field corresponds to an anonymous 4418254721Semaste // struct or union. 4419254721Semaste if (const TagType *TagT = field->getType()->getAs<TagType>()) { 4420254721Semaste if (RecordDecl *Rec = dyn_cast<RecordDecl>(TagT->getDecl())) 4421254721Semaste if (!Rec->getDeclName()) { 4422254721Semaste Rec->setAnonymousStructOrUnion(true); 4423254721Semaste field->setImplicit(); 4424254721Semaste 4425254721Semaste } 4426254721Semaste } 4427254721Semaste } 4428254721Semaste 4429254721Semaste if (field) 4430254721Semaste { 4431254721Semaste field->setAccess (ClangASTContext::ConvertAccessTypeToAccessSpecifier (access)); 4432254721Semaste 4433254721Semaste record_decl->addDecl(field); 4434254721Semaste 4435254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 4436254721Semaste VerifyDecl(field); 4437254721Semaste#endif 4438254721Semaste } 4439254721Semaste } 4440254721Semaste else 4441254721Semaste { 4442254721Semaste ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); 4443254721Semaste 4444254721Semaste if (class_interface_decl) 4445254721Semaste { 4446254721Semaste const bool is_synthesized = false; 4447254721Semaste 4448254721Semaste field_clang_type.GetCompleteType(); 4449254721Semaste 4450254721Semaste field = ObjCIvarDecl::Create (*m_ast, 4451254721Semaste class_interface_decl, 4452254721Semaste SourceLocation(), 4453254721Semaste SourceLocation(), 4454254721Semaste name ? &m_ast->Idents.get(name) : NULL, // Identifier 4455254721Semaste field_clang_type.GetQualType(), // Field type 4456254721Semaste NULL, // TypeSourceInfo * 4457254721Semaste ConvertAccessTypeToObjCIvarAccessControl (access), 4458254721Semaste bit_width, 4459254721Semaste is_synthesized); 4460254721Semaste 4461254721Semaste if (field) 4462254721Semaste { 4463254721Semaste class_interface_decl->addDecl(field); 4464254721Semaste 4465254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 4466254721Semaste VerifyDecl(field); 4467254721Semaste#endif 4468254721Semaste } 4469254721Semaste } 4470254721Semaste } 4471254721Semaste return field; 4472254721Semaste} 4473254721Semaste 4474254721Semastevoid 4475254721SemasteClangASTType::BuildIndirectFields () 4476254721Semaste{ 4477254721Semaste RecordDecl *record_decl = GetAsRecordDecl(); 4478254721Semaste 4479254721Semaste if (!record_decl) 4480254721Semaste return; 4481254721Semaste 4482254721Semaste typedef llvm::SmallVector <IndirectFieldDecl *, 1> IndirectFieldVector; 4483254721Semaste 4484254721Semaste IndirectFieldVector indirect_fields; 4485254721Semaste RecordDecl::field_iterator field_pos; 4486254721Semaste RecordDecl::field_iterator field_end_pos = record_decl->field_end(); 4487254721Semaste RecordDecl::field_iterator last_field_pos = field_end_pos; 4488254721Semaste for (field_pos = record_decl->field_begin(); field_pos != field_end_pos; last_field_pos = field_pos++) 4489254721Semaste { 4490254721Semaste if (field_pos->isAnonymousStructOrUnion()) 4491254721Semaste { 4492254721Semaste QualType field_qual_type = field_pos->getType(); 4493254721Semaste 4494254721Semaste const RecordType *field_record_type = field_qual_type->getAs<RecordType>(); 4495254721Semaste 4496254721Semaste if (!field_record_type) 4497254721Semaste continue; 4498254721Semaste 4499254721Semaste RecordDecl *field_record_decl = field_record_type->getDecl(); 4500254721Semaste 4501254721Semaste if (!field_record_decl) 4502254721Semaste continue; 4503254721Semaste 4504254721Semaste for (RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end(); 4505254721Semaste di != de; 4506254721Semaste ++di) 4507254721Semaste { 4508254721Semaste if (FieldDecl *nested_field_decl = dyn_cast<FieldDecl>(*di)) 4509254721Semaste { 4510254721Semaste NamedDecl **chain = new (*m_ast) NamedDecl*[2]; 4511254721Semaste chain[0] = *field_pos; 4512254721Semaste chain[1] = nested_field_decl; 4513254721Semaste IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast, 4514254721Semaste record_decl, 4515254721Semaste SourceLocation(), 4516254721Semaste nested_field_decl->getIdentifier(), 4517254721Semaste nested_field_decl->getType(), 4518254721Semaste chain, 4519254721Semaste 2); 4520254721Semaste 4521254721Semaste indirect_field->setImplicit(); 4522254721Semaste 4523254721Semaste indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(), 4524254721Semaste nested_field_decl->getAccess())); 4525254721Semaste 4526254721Semaste indirect_fields.push_back(indirect_field); 4527254721Semaste } 4528254721Semaste else if (IndirectFieldDecl *nested_indirect_field_decl = dyn_cast<IndirectFieldDecl>(*di)) 4529254721Semaste { 4530254721Semaste int nested_chain_size = nested_indirect_field_decl->getChainingSize(); 4531254721Semaste NamedDecl **chain = new (*m_ast) NamedDecl*[nested_chain_size + 1]; 4532254721Semaste chain[0] = *field_pos; 4533254721Semaste 4534254721Semaste int chain_index = 1; 4535254721Semaste for (IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(), 4536254721Semaste nce = nested_indirect_field_decl->chain_end(); 4537254721Semaste nci < nce; 4538254721Semaste ++nci) 4539254721Semaste { 4540254721Semaste chain[chain_index] = *nci; 4541254721Semaste chain_index++; 4542254721Semaste } 4543254721Semaste 4544254721Semaste IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*m_ast, 4545254721Semaste record_decl, 4546254721Semaste SourceLocation(), 4547254721Semaste nested_indirect_field_decl->getIdentifier(), 4548254721Semaste nested_indirect_field_decl->getType(), 4549254721Semaste chain, 4550254721Semaste nested_chain_size + 1); 4551254721Semaste 4552254721Semaste indirect_field->setImplicit(); 4553254721Semaste 4554254721Semaste indirect_field->setAccess(ClangASTContext::UnifyAccessSpecifiers(field_pos->getAccess(), 4555254721Semaste nested_indirect_field_decl->getAccess())); 4556254721Semaste 4557254721Semaste indirect_fields.push_back(indirect_field); 4558254721Semaste } 4559254721Semaste } 4560254721Semaste } 4561254721Semaste } 4562254721Semaste 4563254721Semaste // Check the last field to see if it has an incomplete array type as its 4564254721Semaste // last member and if it does, the tell the record decl about it 4565254721Semaste if (last_field_pos != field_end_pos) 4566254721Semaste { 4567254721Semaste if (last_field_pos->getType()->isIncompleteArrayType()) 4568254721Semaste record_decl->hasFlexibleArrayMember(); 4569254721Semaste } 4570254721Semaste 4571254721Semaste for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), ife = indirect_fields.end(); 4572254721Semaste ifi < ife; 4573254721Semaste ++ifi) 4574254721Semaste { 4575254721Semaste record_decl->addDecl(*ifi); 4576254721Semaste } 4577254721Semaste} 4578254721Semaste 4579254721Semasteclang::VarDecl * 4580254721SemasteClangASTType::AddVariableToRecordType (const char *name, 4581254721Semaste const ClangASTType &var_type, 4582254721Semaste AccessType access) 4583254721Semaste{ 4584254721Semaste clang::VarDecl *var_decl = NULL; 4585254721Semaste 4586254721Semaste if (!IsValid() || !var_type.IsValid()) 4587254721Semaste return NULL; 4588254721Semaste 4589254721Semaste RecordDecl *record_decl = GetAsRecordDecl (); 4590254721Semaste if (record_decl) 4591254721Semaste { 4592254721Semaste var_decl = VarDecl::Create (*m_ast, // ASTContext & 4593254721Semaste record_decl, // DeclContext * 4594254721Semaste SourceLocation(), // SourceLocation StartLoc 4595254721Semaste SourceLocation(), // SourceLocation IdLoc 4596254721Semaste name ? &m_ast->Idents.get(name) : NULL, // IdentifierInfo * 4597254721Semaste var_type.GetQualType(), // Variable QualType 4598254721Semaste NULL, // TypeSourceInfo * 4599254721Semaste SC_Static); // StorageClass 4600254721Semaste if (var_decl) 4601254721Semaste { 4602254721Semaste var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access)); 4603254721Semaste record_decl->addDecl(var_decl); 4604254721Semaste 4605254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 4606254721Semaste VerifyDecl(var_decl); 4607254721Semaste#endif 4608254721Semaste } 4609254721Semaste } 4610254721Semaste return var_decl; 4611254721Semaste} 4612254721Semaste 4613254721Semaste 4614254721SemasteCXXMethodDecl * 4615254721SemasteClangASTType::AddMethodToCXXRecordType (const char *name, 4616254721Semaste const ClangASTType &method_clang_type, 4617254721Semaste lldb::AccessType access, 4618254721Semaste bool is_virtual, 4619254721Semaste bool is_static, 4620254721Semaste bool is_inline, 4621254721Semaste bool is_explicit, 4622254721Semaste bool is_attr_used, 4623254721Semaste bool is_artificial) 4624254721Semaste{ 4625254721Semaste if (!IsValid() || !method_clang_type.IsValid() || name == NULL || name[0] == '\0') 4626254721Semaste return NULL; 4627254721Semaste 4628254721Semaste QualType record_qual_type(GetCanonicalQualType()); 4629254721Semaste 4630254721Semaste CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl(); 4631254721Semaste 4632254721Semaste if (cxx_record_decl == NULL) 4633254721Semaste return NULL; 4634254721Semaste 4635254721Semaste QualType method_qual_type (method_clang_type.GetQualType()); 4636254721Semaste 4637254721Semaste CXXMethodDecl *cxx_method_decl = NULL; 4638254721Semaste 4639254721Semaste DeclarationName decl_name (&m_ast->Idents.get(name)); 4640254721Semaste 4641254721Semaste const clang::FunctionType *function_type = dyn_cast<FunctionType>(method_qual_type.getTypePtr()); 4642254721Semaste 4643254721Semaste if (function_type == NULL) 4644254721Semaste return NULL; 4645254721Semaste 4646254721Semaste const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_type)); 4647254721Semaste 4648254721Semaste if (!method_function_prototype) 4649254721Semaste return NULL; 4650254721Semaste 4651254721Semaste unsigned int num_params = method_function_prototype->getNumArgs(); 4652254721Semaste 4653254721Semaste CXXDestructorDecl *cxx_dtor_decl(NULL); 4654254721Semaste CXXConstructorDecl *cxx_ctor_decl(NULL); 4655254721Semaste 4656254721Semaste if (is_artificial) 4657254721Semaste return NULL; // skip everything artificial 4658254721Semaste 4659254721Semaste if (name[0] == '~') 4660254721Semaste { 4661254721Semaste cxx_dtor_decl = CXXDestructorDecl::Create (*m_ast, 4662254721Semaste cxx_record_decl, 4663254721Semaste SourceLocation(), 4664254721Semaste DeclarationNameInfo (m_ast->DeclarationNames.getCXXDestructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()), 4665254721Semaste method_qual_type, 4666254721Semaste NULL, 4667254721Semaste is_inline, 4668254721Semaste is_artificial); 4669254721Semaste cxx_method_decl = cxx_dtor_decl; 4670254721Semaste } 4671254721Semaste else if (decl_name == cxx_record_decl->getDeclName()) 4672254721Semaste { 4673254721Semaste cxx_ctor_decl = CXXConstructorDecl::Create (*m_ast, 4674254721Semaste cxx_record_decl, 4675254721Semaste SourceLocation(), 4676254721Semaste DeclarationNameInfo (m_ast->DeclarationNames.getCXXConstructorName (m_ast->getCanonicalType (record_qual_type)), SourceLocation()), 4677254721Semaste method_qual_type, 4678254721Semaste NULL, // TypeSourceInfo * 4679254721Semaste is_explicit, 4680254721Semaste is_inline, 4681254721Semaste is_artificial, 4682254721Semaste false /*is_constexpr*/); 4683254721Semaste cxx_method_decl = cxx_ctor_decl; 4684254721Semaste } 4685254721Semaste else 4686254721Semaste { 4687254721Semaste clang::StorageClass SC = is_static ? SC_Static : SC_None; 4688254721Semaste OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS; 4689254721Semaste 4690254721Semaste if (IsOperator (name, op_kind)) 4691254721Semaste { 4692254721Semaste if (op_kind != NUM_OVERLOADED_OPERATORS) 4693254721Semaste { 4694254721Semaste // Check the number of operator parameters. Sometimes we have 4695254721Semaste // seen bad DWARF that doesn't correctly describe operators and 4696254721Semaste // if we try to create a methed and add it to the class, clang 4697254721Semaste // will assert and crash, so we need to make sure things are 4698254721Semaste // acceptable. 4699254721Semaste if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params)) 4700254721Semaste return NULL; 4701254721Semaste cxx_method_decl = CXXMethodDecl::Create (*m_ast, 4702254721Semaste cxx_record_decl, 4703254721Semaste SourceLocation(), 4704254721Semaste DeclarationNameInfo (m_ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()), 4705254721Semaste method_qual_type, 4706254721Semaste NULL, // TypeSourceInfo * 4707254721Semaste SC, 4708254721Semaste is_inline, 4709254721Semaste false /*is_constexpr*/, 4710254721Semaste SourceLocation()); 4711254721Semaste } 4712254721Semaste else if (num_params == 0) 4713254721Semaste { 4714254721Semaste // Conversion operators don't take params... 4715254721Semaste cxx_method_decl = CXXConversionDecl::Create (*m_ast, 4716254721Semaste cxx_record_decl, 4717254721Semaste SourceLocation(), 4718254721Semaste DeclarationNameInfo (m_ast->DeclarationNames.getCXXConversionFunctionName (m_ast->getCanonicalType (function_type->getResultType())), SourceLocation()), 4719254721Semaste method_qual_type, 4720254721Semaste NULL, // TypeSourceInfo * 4721254721Semaste is_inline, 4722254721Semaste is_explicit, 4723254721Semaste false /*is_constexpr*/, 4724254721Semaste SourceLocation()); 4725254721Semaste } 4726254721Semaste } 4727254721Semaste 4728254721Semaste if (cxx_method_decl == NULL) 4729254721Semaste { 4730254721Semaste cxx_method_decl = CXXMethodDecl::Create (*m_ast, 4731254721Semaste cxx_record_decl, 4732254721Semaste SourceLocation(), 4733254721Semaste DeclarationNameInfo (decl_name, SourceLocation()), 4734254721Semaste method_qual_type, 4735254721Semaste NULL, // TypeSourceInfo * 4736254721Semaste SC, 4737254721Semaste is_inline, 4738254721Semaste false /*is_constexpr*/, 4739254721Semaste SourceLocation()); 4740254721Semaste } 4741254721Semaste } 4742254721Semaste 4743254721Semaste AccessSpecifier access_specifier = ClangASTContext::ConvertAccessTypeToAccessSpecifier (access); 4744254721Semaste 4745254721Semaste cxx_method_decl->setAccess (access_specifier); 4746254721Semaste cxx_method_decl->setVirtualAsWritten (is_virtual); 4747254721Semaste 4748254721Semaste if (is_attr_used) 4749254721Semaste cxx_method_decl->addAttr(::new (*m_ast) UsedAttr(SourceRange(), *m_ast)); 4750254721Semaste 4751254721Semaste // Populate the method decl with parameter decls 4752254721Semaste 4753254721Semaste llvm::SmallVector<ParmVarDecl *, 12> params; 4754254721Semaste 4755254721Semaste for (unsigned param_index = 0; 4756254721Semaste param_index < num_params; 4757254721Semaste ++param_index) 4758254721Semaste { 4759254721Semaste params.push_back (ParmVarDecl::Create (*m_ast, 4760254721Semaste cxx_method_decl, 4761254721Semaste SourceLocation(), 4762254721Semaste SourceLocation(), 4763254721Semaste NULL, // anonymous 4764254721Semaste method_function_prototype->getArgType(param_index), 4765254721Semaste NULL, 4766254721Semaste SC_None, 4767254721Semaste NULL)); 4768254721Semaste } 4769254721Semaste 4770254721Semaste cxx_method_decl->setParams (ArrayRef<ParmVarDecl*>(params)); 4771254721Semaste 4772254721Semaste cxx_record_decl->addDecl (cxx_method_decl); 4773254721Semaste 4774254721Semaste // Sometimes the debug info will mention a constructor (default/copy/move), 4775254721Semaste // destructor, or assignment operator (copy/move) but there won't be any 4776254721Semaste // version of this in the code. So we check if the function was artificially 4777254721Semaste // generated and if it is trivial and this lets the compiler/backend know 4778254721Semaste // that it can inline the IR for these when it needs to and we can avoid a 4779254721Semaste // "missing function" error when running expressions. 4780254721Semaste 4781254721Semaste if (is_artificial) 4782254721Semaste { 4783254721Semaste if (cxx_ctor_decl && 4784254721Semaste ((cxx_ctor_decl->isDefaultConstructor() && cxx_record_decl->hasTrivialDefaultConstructor ()) || 4785254721Semaste (cxx_ctor_decl->isCopyConstructor() && cxx_record_decl->hasTrivialCopyConstructor ()) || 4786254721Semaste (cxx_ctor_decl->isMoveConstructor() && cxx_record_decl->hasTrivialMoveConstructor ()) )) 4787254721Semaste { 4788254721Semaste cxx_ctor_decl->setDefaulted(); 4789254721Semaste cxx_ctor_decl->setTrivial(true); 4790254721Semaste } 4791254721Semaste else if (cxx_dtor_decl) 4792254721Semaste { 4793254721Semaste if (cxx_record_decl->hasTrivialDestructor()) 4794254721Semaste { 4795254721Semaste cxx_dtor_decl->setDefaulted(); 4796254721Semaste cxx_dtor_decl->setTrivial(true); 4797254721Semaste } 4798254721Semaste } 4799254721Semaste else if ((cxx_method_decl->isCopyAssignmentOperator() && cxx_record_decl->hasTrivialCopyAssignment()) || 4800254721Semaste (cxx_method_decl->isMoveAssignmentOperator() && cxx_record_decl->hasTrivialMoveAssignment())) 4801254721Semaste { 4802254721Semaste cxx_method_decl->setDefaulted(); 4803254721Semaste cxx_method_decl->setTrivial(true); 4804254721Semaste } 4805254721Semaste } 4806254721Semaste 4807254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 4808254721Semaste VerifyDecl(cxx_method_decl); 4809254721Semaste#endif 4810254721Semaste 4811254721Semaste // printf ("decl->isPolymorphic() = %i\n", cxx_record_decl->isPolymorphic()); 4812254721Semaste // printf ("decl->isAggregate() = %i\n", cxx_record_decl->isAggregate()); 4813254721Semaste // printf ("decl->isPOD() = %i\n", cxx_record_decl->isPOD()); 4814254721Semaste // printf ("decl->isEmpty() = %i\n", cxx_record_decl->isEmpty()); 4815254721Semaste // printf ("decl->isAbstract() = %i\n", cxx_record_decl->isAbstract()); 4816254721Semaste // printf ("decl->hasTrivialConstructor() = %i\n", cxx_record_decl->hasTrivialConstructor()); 4817254721Semaste // printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor()); 4818254721Semaste // printf ("decl->hasTrivialCopyAssignment() = %i\n", cxx_record_decl->hasTrivialCopyAssignment()); 4819254721Semaste // printf ("decl->hasTrivialDestructor() = %i\n", cxx_record_decl->hasTrivialDestructor()); 4820254721Semaste return cxx_method_decl; 4821254721Semaste} 4822254721Semaste 4823254721Semaste 4824254721Semaste#pragma mark C++ Base Classes 4825254721Semaste 4826254721SemasteCXXBaseSpecifier * 4827254721SemasteClangASTType::CreateBaseClassSpecifier (AccessType access, bool is_virtual, bool base_of_class) 4828254721Semaste{ 4829254721Semaste if (IsValid()) 4830254721Semaste return new CXXBaseSpecifier (SourceRange(), 4831254721Semaste is_virtual, 4832254721Semaste base_of_class, 4833254721Semaste ClangASTContext::ConvertAccessTypeToAccessSpecifier (access), 4834254721Semaste m_ast->getTrivialTypeSourceInfo (GetQualType()), 4835254721Semaste SourceLocation()); 4836254721Semaste return NULL; 4837254721Semaste} 4838254721Semaste 4839254721Semastevoid 4840254721SemasteClangASTType::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes) 4841254721Semaste{ 4842254721Semaste for (unsigned i=0; i<num_base_classes; ++i) 4843254721Semaste { 4844254721Semaste delete base_classes[i]; 4845254721Semaste base_classes[i] = NULL; 4846254721Semaste } 4847254721Semaste} 4848254721Semaste 4849254721Semastebool 4850254721SemasteClangASTType::SetBaseClassesForClassType (CXXBaseSpecifier const * const *base_classes, 4851254721Semaste unsigned num_base_classes) 4852254721Semaste{ 4853254721Semaste if (IsValid()) 4854254721Semaste { 4855254721Semaste CXXRecordDecl *cxx_record_decl = GetAsCXXRecordDecl(); 4856254721Semaste if (cxx_record_decl) 4857254721Semaste { 4858254721Semaste cxx_record_decl->setBases(base_classes, num_base_classes); 4859254721Semaste return true; 4860254721Semaste } 4861254721Semaste } 4862254721Semaste return false; 4863254721Semaste} 4864254721Semaste 4865254721Semastebool 4866254721SemasteClangASTType::SetObjCSuperClass (const ClangASTType &superclass_clang_type) 4867254721Semaste{ 4868254721Semaste if (IsValid() && superclass_clang_type.IsValid()) 4869254721Semaste { 4870254721Semaste ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); 4871254721Semaste ObjCInterfaceDecl *super_interface_decl = superclass_clang_type.GetAsObjCInterfaceDecl (); 4872254721Semaste if (class_interface_decl && super_interface_decl) 4873254721Semaste { 4874254721Semaste class_interface_decl->setSuperClass(super_interface_decl); 4875254721Semaste return true; 4876254721Semaste } 4877254721Semaste } 4878254721Semaste return false; 4879254721Semaste} 4880254721Semaste 4881254721Semastebool 4882254721SemasteClangASTType::AddObjCClassProperty (const char *property_name, 4883254721Semaste const ClangASTType &property_clang_type, 4884254721Semaste ObjCIvarDecl *ivar_decl, 4885254721Semaste const char *property_setter_name, 4886254721Semaste const char *property_getter_name, 4887254721Semaste uint32_t property_attributes, 4888254721Semaste ClangASTMetadata *metadata) 4889254721Semaste{ 4890254721Semaste if (!IsValid() || !property_clang_type.IsValid() || property_name == NULL || property_name[0] == '\0') 4891254721Semaste return false; 4892254721Semaste 4893254721Semaste ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); 4894254721Semaste 4895254721Semaste if (class_interface_decl) 4896254721Semaste { 4897254721Semaste ClangASTType property_clang_type_to_access; 4898254721Semaste 4899254721Semaste if (property_clang_type.IsValid()) 4900254721Semaste property_clang_type_to_access = property_clang_type; 4901254721Semaste else if (ivar_decl) 4902254721Semaste property_clang_type_to_access = ClangASTType (m_ast, ivar_decl->getType()); 4903254721Semaste 4904254721Semaste if (class_interface_decl && property_clang_type_to_access.IsValid()) 4905254721Semaste { 4906254721Semaste clang::TypeSourceInfo *prop_type_source; 4907254721Semaste if (ivar_decl) 4908254721Semaste prop_type_source = m_ast->getTrivialTypeSourceInfo (ivar_decl->getType()); 4909254721Semaste else 4910254721Semaste prop_type_source = m_ast->getTrivialTypeSourceInfo (property_clang_type.GetQualType()); 4911254721Semaste 4912254721Semaste ObjCPropertyDecl *property_decl = ObjCPropertyDecl::Create (*m_ast, 4913254721Semaste class_interface_decl, 4914254721Semaste SourceLocation(), // Source Location 4915254721Semaste &m_ast->Idents.get(property_name), 4916254721Semaste SourceLocation(), //Source Location for AT 4917254721Semaste SourceLocation(), //Source location for ( 4918254721Semaste prop_type_source); 4919254721Semaste 4920254721Semaste if (property_decl) 4921254721Semaste { 4922254721Semaste if (metadata) 4923254721Semaste ClangASTContext::SetMetadata(m_ast, property_decl, *metadata); 4924254721Semaste 4925254721Semaste class_interface_decl->addDecl (property_decl); 4926254721Semaste 4927254721Semaste Selector setter_sel, getter_sel; 4928254721Semaste 4929254721Semaste if (property_setter_name != NULL) 4930254721Semaste { 4931254721Semaste std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1); 4932254721Semaste clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(property_setter_no_colon.c_str()); 4933254721Semaste setter_sel = m_ast->Selectors.getSelector(1, &setter_ident); 4934254721Semaste } 4935254721Semaste else if (!(property_attributes & DW_APPLE_PROPERTY_readonly)) 4936254721Semaste { 4937254721Semaste std::string setter_sel_string("set"); 4938254721Semaste setter_sel_string.push_back(::toupper(property_name[0])); 4939254721Semaste setter_sel_string.append(&property_name[1]); 4940254721Semaste clang::IdentifierInfo *setter_ident = &m_ast->Idents.get(setter_sel_string.c_str()); 4941254721Semaste setter_sel = m_ast->Selectors.getSelector(1, &setter_ident); 4942254721Semaste } 4943254721Semaste property_decl->setSetterName(setter_sel); 4944254721Semaste property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter); 4945254721Semaste 4946254721Semaste if (property_getter_name != NULL) 4947254721Semaste { 4948254721Semaste clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_getter_name); 4949254721Semaste getter_sel = m_ast->Selectors.getSelector(0, &getter_ident); 4950254721Semaste } 4951254721Semaste else 4952254721Semaste { 4953254721Semaste clang::IdentifierInfo *getter_ident = &m_ast->Idents.get(property_name); 4954254721Semaste getter_sel = m_ast->Selectors.getSelector(0, &getter_ident); 4955254721Semaste } 4956254721Semaste property_decl->setGetterName(getter_sel); 4957254721Semaste property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_getter); 4958254721Semaste 4959254721Semaste if (ivar_decl) 4960254721Semaste property_decl->setPropertyIvarDecl (ivar_decl); 4961254721Semaste 4962254721Semaste if (property_attributes & DW_APPLE_PROPERTY_readonly) 4963254721Semaste property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readonly); 4964254721Semaste if (property_attributes & DW_APPLE_PROPERTY_readwrite) 4965254721Semaste property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readwrite); 4966254721Semaste if (property_attributes & DW_APPLE_PROPERTY_assign) 4967254721Semaste property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_assign); 4968254721Semaste if (property_attributes & DW_APPLE_PROPERTY_retain) 4969254721Semaste property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_retain); 4970254721Semaste if (property_attributes & DW_APPLE_PROPERTY_copy) 4971254721Semaste property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_copy); 4972254721Semaste if (property_attributes & DW_APPLE_PROPERTY_nonatomic) 4973254721Semaste property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_nonatomic); 4974254721Semaste 4975254721Semaste if (!getter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(getter_sel)) 4976254721Semaste { 4977254721Semaste const bool isInstance = true; 4978254721Semaste const bool isVariadic = false; 4979254721Semaste const bool isSynthesized = false; 4980254721Semaste const bool isImplicitlyDeclared = true; 4981254721Semaste const bool isDefined = false; 4982254721Semaste const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None; 4983254721Semaste const bool HasRelatedResultType = false; 4984254721Semaste 4985254721Semaste ObjCMethodDecl *getter = ObjCMethodDecl::Create (*m_ast, 4986254721Semaste SourceLocation(), 4987254721Semaste SourceLocation(), 4988254721Semaste getter_sel, 4989254721Semaste property_clang_type_to_access.GetQualType(), 4990254721Semaste NULL, 4991254721Semaste class_interface_decl, 4992254721Semaste isInstance, 4993254721Semaste isVariadic, 4994254721Semaste isSynthesized, 4995254721Semaste isImplicitlyDeclared, 4996254721Semaste isDefined, 4997254721Semaste impControl, 4998254721Semaste HasRelatedResultType); 4999254721Semaste 5000254721Semaste if (getter && metadata) 5001254721Semaste ClangASTContext::SetMetadata(m_ast, getter, *metadata); 5002254721Semaste 5003254721Semaste getter->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(), ArrayRef<SourceLocation>()); 5004254721Semaste 5005254721Semaste class_interface_decl->addDecl(getter); 5006254721Semaste } 5007254721Semaste 5008254721Semaste if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel)) 5009254721Semaste { 5010254721Semaste QualType result_type = m_ast->VoidTy; 5011254721Semaste 5012254721Semaste const bool isInstance = true; 5013254721Semaste const bool isVariadic = false; 5014254721Semaste const bool isSynthesized = false; 5015254721Semaste const bool isImplicitlyDeclared = true; 5016254721Semaste const bool isDefined = false; 5017254721Semaste const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None; 5018254721Semaste const bool HasRelatedResultType = false; 5019254721Semaste 5020254721Semaste ObjCMethodDecl *setter = ObjCMethodDecl::Create (*m_ast, 5021254721Semaste SourceLocation(), 5022254721Semaste SourceLocation(), 5023254721Semaste setter_sel, 5024254721Semaste result_type, 5025254721Semaste NULL, 5026254721Semaste class_interface_decl, 5027254721Semaste isInstance, 5028254721Semaste isVariadic, 5029254721Semaste isSynthesized, 5030254721Semaste isImplicitlyDeclared, 5031254721Semaste isDefined, 5032254721Semaste impControl, 5033254721Semaste HasRelatedResultType); 5034254721Semaste 5035254721Semaste if (setter && metadata) 5036254721Semaste ClangASTContext::SetMetadata(m_ast, setter, *metadata); 5037254721Semaste 5038254721Semaste llvm::SmallVector<ParmVarDecl *, 1> params; 5039254721Semaste 5040254721Semaste params.push_back (ParmVarDecl::Create (*m_ast, 5041254721Semaste setter, 5042254721Semaste SourceLocation(), 5043254721Semaste SourceLocation(), 5044254721Semaste NULL, // anonymous 5045254721Semaste property_clang_type_to_access.GetQualType(), 5046254721Semaste NULL, 5047254721Semaste SC_Auto, 5048254721Semaste NULL)); 5049254721Semaste 5050254721Semaste setter->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>()); 5051254721Semaste 5052254721Semaste class_interface_decl->addDecl(setter); 5053254721Semaste } 5054254721Semaste 5055254721Semaste return true; 5056254721Semaste } 5057254721Semaste } 5058254721Semaste } 5059254721Semaste return false; 5060254721Semaste} 5061254721Semaste 5062254721Semastebool 5063254721SemasteClangASTType::IsObjCClassTypeAndHasIVars (bool check_superclass) const 5064254721Semaste{ 5065254721Semaste ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl (); 5066254721Semaste if (class_interface_decl) 5067254721Semaste return ObjCDeclHasIVars (class_interface_decl, check_superclass); 5068254721Semaste return false; 5069254721Semaste} 5070254721Semaste 5071254721Semaste 5072254721SemasteObjCMethodDecl * 5073254721SemasteClangASTType::AddMethodToObjCObjectType (const char *name, // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]") 5074254721Semaste const ClangASTType &method_clang_type, 5075254721Semaste lldb::AccessType access, 5076254721Semaste bool is_artificial) 5077254721Semaste{ 5078254721Semaste if (!IsValid() || !method_clang_type.IsValid()) 5079254721Semaste return NULL; 5080254721Semaste 5081254721Semaste ObjCInterfaceDecl *class_interface_decl = GetAsObjCInterfaceDecl(); 5082254721Semaste 5083254721Semaste if (class_interface_decl == NULL) 5084254721Semaste return NULL; 5085254721Semaste 5086254721Semaste const char *selector_start = ::strchr (name, ' '); 5087254721Semaste if (selector_start == NULL) 5088254721Semaste return NULL; 5089254721Semaste 5090254721Semaste selector_start++; 5091254721Semaste llvm::SmallVector<IdentifierInfo *, 12> selector_idents; 5092254721Semaste 5093254721Semaste size_t len = 0; 5094254721Semaste const char *start; 5095254721Semaste //printf ("name = '%s'\n", name); 5096254721Semaste 5097254721Semaste unsigned num_selectors_with_args = 0; 5098254721Semaste for (start = selector_start; 5099254721Semaste start && *start != '\0' && *start != ']'; 5100254721Semaste start += len) 5101254721Semaste { 5102254721Semaste len = ::strcspn(start, ":]"); 5103254721Semaste bool has_arg = (start[len] == ':'); 5104254721Semaste if (has_arg) 5105254721Semaste ++num_selectors_with_args; 5106254721Semaste selector_idents.push_back (&m_ast->Idents.get (StringRef (start, len))); 5107254721Semaste if (has_arg) 5108254721Semaste len += 1; 5109254721Semaste } 5110254721Semaste 5111254721Semaste 5112254721Semaste if (selector_idents.size() == 0) 5113254721Semaste return 0; 5114254721Semaste 5115254721Semaste clang::Selector method_selector = m_ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0, 5116254721Semaste selector_idents.data()); 5117254721Semaste 5118254721Semaste QualType method_qual_type (method_clang_type.GetQualType()); 5119254721Semaste 5120254721Semaste // Populate the method decl with parameter decls 5121254721Semaste const clang::Type *method_type(method_qual_type.getTypePtr()); 5122254721Semaste 5123254721Semaste if (method_type == NULL) 5124254721Semaste return NULL; 5125254721Semaste 5126254721Semaste const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type)); 5127254721Semaste 5128254721Semaste if (!method_function_prototype) 5129254721Semaste return NULL; 5130254721Semaste 5131254721Semaste 5132254721Semaste bool is_variadic = false; 5133254721Semaste bool is_synthesized = false; 5134254721Semaste bool is_defined = false; 5135254721Semaste ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None; 5136254721Semaste 5137254721Semaste const unsigned num_args = method_function_prototype->getNumArgs(); 5138254721Semaste 5139254721Semaste if (num_args != num_selectors_with_args) 5140254721Semaste return NULL; // some debug information is corrupt. We are not going to deal with it. 5141254721Semaste 5142254721Semaste ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*m_ast, 5143254721Semaste SourceLocation(), // beginLoc, 5144254721Semaste SourceLocation(), // endLoc, 5145254721Semaste method_selector, 5146254721Semaste method_function_prototype->getResultType(), 5147254721Semaste NULL, // TypeSourceInfo *ResultTInfo, 5148254721Semaste GetDeclContextForType (), 5149254721Semaste name[0] == '-', 5150254721Semaste is_variadic, 5151254721Semaste is_synthesized, 5152254721Semaste true, // is_implicitly_declared; we force this to true because we don't have source locations 5153254721Semaste is_defined, 5154254721Semaste imp_control, 5155254721Semaste false /*has_related_result_type*/); 5156254721Semaste 5157254721Semaste 5158254721Semaste if (objc_method_decl == NULL) 5159254721Semaste return NULL; 5160254721Semaste 5161254721Semaste if (num_args > 0) 5162254721Semaste { 5163254721Semaste llvm::SmallVector<ParmVarDecl *, 12> params; 5164254721Semaste 5165254721Semaste for (unsigned param_index = 0; param_index < num_args; ++param_index) 5166254721Semaste { 5167254721Semaste params.push_back (ParmVarDecl::Create (*m_ast, 5168254721Semaste objc_method_decl, 5169254721Semaste SourceLocation(), 5170254721Semaste SourceLocation(), 5171254721Semaste NULL, // anonymous 5172254721Semaste method_function_prototype->getArgType(param_index), 5173254721Semaste NULL, 5174254721Semaste SC_Auto, 5175254721Semaste NULL)); 5176254721Semaste } 5177254721Semaste 5178254721Semaste objc_method_decl->setMethodParams(*m_ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>()); 5179254721Semaste } 5180254721Semaste 5181254721Semaste class_interface_decl->addDecl (objc_method_decl); 5182254721Semaste 5183254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 5184254721Semaste VerifyDecl(objc_method_decl); 5185254721Semaste#endif 5186254721Semaste 5187254721Semaste return objc_method_decl; 5188254721Semaste} 5189254721Semaste 5190254721Semaste 5191254721Semasteclang::DeclContext * 5192254721SemasteClangASTType::GetDeclContextForType () const 5193254721Semaste{ 5194254721Semaste if (!IsValid()) 5195254721Semaste return NULL; 5196254721Semaste 5197254721Semaste QualType qual_type(GetCanonicalQualType()); 5198254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5199254721Semaste switch (type_class) 5200254721Semaste { 5201254721Semaste case clang::Type::UnaryTransform: break; 5202254721Semaste case clang::Type::FunctionNoProto: break; 5203254721Semaste case clang::Type::FunctionProto: break; 5204254721Semaste case clang::Type::IncompleteArray: break; 5205254721Semaste case clang::Type::VariableArray: break; 5206254721Semaste case clang::Type::ConstantArray: break; 5207254721Semaste case clang::Type::DependentSizedArray: break; 5208254721Semaste case clang::Type::ExtVector: break; 5209254721Semaste case clang::Type::DependentSizedExtVector: break; 5210254721Semaste case clang::Type::Vector: break; 5211254721Semaste case clang::Type::Builtin: break; 5212254721Semaste case clang::Type::BlockPointer: break; 5213254721Semaste case clang::Type::Pointer: break; 5214254721Semaste case clang::Type::LValueReference: break; 5215254721Semaste case clang::Type::RValueReference: break; 5216254721Semaste case clang::Type::MemberPointer: break; 5217254721Semaste case clang::Type::Complex: break; 5218254721Semaste case clang::Type::ObjCObject: break; 5219254721Semaste case clang::Type::ObjCInterface: return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface(); 5220254721Semaste case clang::Type::ObjCObjectPointer: return ClangASTType (m_ast, cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType()).GetDeclContextForType(); 5221254721Semaste case clang::Type::Record: return cast<RecordType>(qual_type)->getDecl(); 5222254721Semaste case clang::Type::Enum: return cast<EnumType>(qual_type)->getDecl(); 5223254721Semaste case clang::Type::Typedef: return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).GetDeclContextForType(); 5224254721Semaste case clang::Type::Elaborated: return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).GetDeclContextForType(); 5225254721Semaste case clang::Type::Paren: return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).GetDeclContextForType(); 5226254721Semaste case clang::Type::TypeOfExpr: break; 5227254721Semaste case clang::Type::TypeOf: break; 5228254721Semaste case clang::Type::Decltype: break; 5229254721Semaste //case clang::Type::QualifiedName: break; 5230254721Semaste case clang::Type::TemplateSpecialization: break; 5231254721Semaste case clang::Type::DependentTemplateSpecialization: break; 5232254721Semaste case clang::Type::TemplateTypeParm: break; 5233254721Semaste case clang::Type::SubstTemplateTypeParm: break; 5234254721Semaste case clang::Type::SubstTemplateTypeParmPack:break; 5235254721Semaste case clang::Type::PackExpansion: break; 5236254721Semaste case clang::Type::UnresolvedUsing: break; 5237254721Semaste case clang::Type::Attributed: break; 5238254721Semaste case clang::Type::Auto: break; 5239254721Semaste case clang::Type::InjectedClassName: break; 5240254721Semaste case clang::Type::DependentName: break; 5241254721Semaste case clang::Type::Atomic: break; 5242263508Sdim 5243263508Sdim // pointer type decayed from an array or function type. 5244263508Sdim case clang::Type::Decayed: break; 5245254721Semaste } 5246254721Semaste // No DeclContext in this type... 5247254721Semaste return NULL; 5248254721Semaste} 5249254721Semaste 5250254721Semastebool 5251254721SemasteClangASTType::SetDefaultAccessForRecordFields (int default_accessibility, 5252254721Semaste int *assigned_accessibilities, 5253254721Semaste size_t num_assigned_accessibilities) 5254254721Semaste{ 5255254721Semaste if (IsValid()) 5256254721Semaste { 5257254721Semaste RecordDecl *record_decl = GetAsRecordDecl(); 5258254721Semaste if (record_decl) 5259254721Semaste { 5260254721Semaste uint32_t field_idx; 5261254721Semaste RecordDecl::field_iterator field, field_end; 5262254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0; 5263254721Semaste field != field_end; 5264254721Semaste ++field, ++field_idx) 5265254721Semaste { 5266254721Semaste // If no accessibility was assigned, assign the correct one 5267254721Semaste if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none) 5268254721Semaste field->setAccess ((AccessSpecifier)default_accessibility); 5269254721Semaste } 5270254721Semaste return true; 5271254721Semaste } 5272254721Semaste } 5273254721Semaste return false; 5274254721Semaste} 5275254721Semaste 5276254721Semaste 5277254721Semastebool 5278254721SemasteClangASTType::SetHasExternalStorage (bool has_extern) 5279254721Semaste{ 5280254721Semaste if (!IsValid()) 5281254721Semaste return false; 5282254721Semaste 5283254721Semaste QualType qual_type (GetCanonicalQualType()); 5284254721Semaste 5285254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5286254721Semaste switch (type_class) 5287254721Semaste { 5288254721Semaste case clang::Type::Record: 5289254721Semaste { 5290254721Semaste CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 5291254721Semaste if (cxx_record_decl) 5292254721Semaste { 5293254721Semaste cxx_record_decl->setHasExternalLexicalStorage (has_extern); 5294254721Semaste cxx_record_decl->setHasExternalVisibleStorage (has_extern); 5295254721Semaste return true; 5296254721Semaste } 5297254721Semaste } 5298254721Semaste break; 5299254721Semaste 5300254721Semaste case clang::Type::Enum: 5301254721Semaste { 5302254721Semaste EnumDecl *enum_decl = cast<EnumType>(qual_type)->getDecl(); 5303254721Semaste if (enum_decl) 5304254721Semaste { 5305254721Semaste enum_decl->setHasExternalLexicalStorage (has_extern); 5306254721Semaste enum_decl->setHasExternalVisibleStorage (has_extern); 5307254721Semaste return true; 5308254721Semaste } 5309254721Semaste } 5310254721Semaste break; 5311254721Semaste 5312254721Semaste case clang::Type::ObjCObject: 5313254721Semaste case clang::Type::ObjCInterface: 5314254721Semaste { 5315254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 5316254721Semaste assert (objc_class_type); 5317254721Semaste if (objc_class_type) 5318254721Semaste { 5319254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 5320254721Semaste 5321254721Semaste if (class_interface_decl) 5322254721Semaste { 5323254721Semaste class_interface_decl->setHasExternalLexicalStorage (has_extern); 5324254721Semaste class_interface_decl->setHasExternalVisibleStorage (has_extern); 5325254721Semaste return true; 5326254721Semaste } 5327254721Semaste } 5328254721Semaste } 5329254721Semaste break; 5330254721Semaste 5331254721Semaste case clang::Type::Typedef: 5332254721Semaste return ClangASTType (m_ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType()).SetHasExternalStorage (has_extern); 5333254721Semaste 5334254721Semaste case clang::Type::Elaborated: 5335254721Semaste return ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).SetHasExternalStorage (has_extern); 5336254721Semaste 5337254721Semaste case clang::Type::Paren: 5338254721Semaste return ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).SetHasExternalStorage (has_extern); 5339254721Semaste 5340254721Semaste default: 5341254721Semaste break; 5342254721Semaste } 5343254721Semaste return false; 5344254721Semaste} 5345254721Semaste 5346254721Semastebool 5347254721SemasteClangASTType::SetTagTypeKind (int kind) const 5348254721Semaste{ 5349254721Semaste if (IsValid()) 5350254721Semaste { 5351254721Semaste QualType tag_qual_type(GetQualType()); 5352254721Semaste const clang::Type *clang_type = tag_qual_type.getTypePtr(); 5353254721Semaste if (clang_type) 5354254721Semaste { 5355254721Semaste const TagType *tag_type = dyn_cast<TagType>(clang_type); 5356254721Semaste if (tag_type) 5357254721Semaste { 5358254721Semaste TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl()); 5359254721Semaste if (tag_decl) 5360254721Semaste { 5361254721Semaste tag_decl->setTagKind ((TagDecl::TagKind)kind); 5362254721Semaste return true; 5363254721Semaste } 5364254721Semaste } 5365254721Semaste } 5366254721Semaste } 5367254721Semaste return false; 5368254721Semaste} 5369254721Semaste 5370254721Semaste 5371254721Semaste#pragma mark TagDecl 5372254721Semaste 5373254721Semastebool 5374254721SemasteClangASTType::StartTagDeclarationDefinition () 5375254721Semaste{ 5376254721Semaste if (IsValid()) 5377254721Semaste { 5378254721Semaste QualType qual_type (GetQualType()); 5379254721Semaste const clang::Type *t = qual_type.getTypePtr(); 5380254721Semaste if (t) 5381254721Semaste { 5382254721Semaste const TagType *tag_type = dyn_cast<TagType>(t); 5383254721Semaste if (tag_type) 5384254721Semaste { 5385254721Semaste TagDecl *tag_decl = tag_type->getDecl(); 5386254721Semaste if (tag_decl) 5387254721Semaste { 5388254721Semaste tag_decl->startDefinition(); 5389254721Semaste return true; 5390254721Semaste } 5391254721Semaste } 5392254721Semaste 5393254721Semaste const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(t); 5394254721Semaste if (object_type) 5395254721Semaste { 5396254721Semaste ObjCInterfaceDecl *interface_decl = object_type->getInterface(); 5397254721Semaste if (interface_decl) 5398254721Semaste { 5399254721Semaste interface_decl->startDefinition(); 5400254721Semaste return true; 5401254721Semaste } 5402254721Semaste } 5403254721Semaste } 5404254721Semaste } 5405254721Semaste return false; 5406254721Semaste} 5407254721Semaste 5408254721Semastebool 5409254721SemasteClangASTType::CompleteTagDeclarationDefinition () 5410254721Semaste{ 5411254721Semaste if (IsValid()) 5412254721Semaste { 5413254721Semaste QualType qual_type (GetQualType()); 5414254721Semaste 5415254721Semaste CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl(); 5416254721Semaste 5417254721Semaste if (cxx_record_decl) 5418254721Semaste { 5419254721Semaste cxx_record_decl->completeDefinition(); 5420254721Semaste 5421254721Semaste return true; 5422254721Semaste } 5423254721Semaste 5424254721Semaste const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr()); 5425254721Semaste 5426254721Semaste if (enum_type) 5427254721Semaste { 5428254721Semaste EnumDecl *enum_decl = enum_type->getDecl(); 5429254721Semaste 5430254721Semaste if (enum_decl) 5431254721Semaste { 5432254721Semaste /// TODO This really needs to be fixed. 5433254721Semaste 5434254721Semaste unsigned NumPositiveBits = 1; 5435254721Semaste unsigned NumNegativeBits = 0; 5436254721Semaste 5437254721Semaste QualType promotion_qual_type; 5438254721Semaste // If the enum integer type is less than an integer in bit width, 5439254721Semaste // then we must promote it to an integer size. 5440254721Semaste if (m_ast->getTypeSize(enum_decl->getIntegerType()) < m_ast->getTypeSize(m_ast->IntTy)) 5441254721Semaste { 5442254721Semaste if (enum_decl->getIntegerType()->isSignedIntegerType()) 5443254721Semaste promotion_qual_type = m_ast->IntTy; 5444254721Semaste else 5445254721Semaste promotion_qual_type = m_ast->UnsignedIntTy; 5446254721Semaste } 5447254721Semaste else 5448254721Semaste promotion_qual_type = enum_decl->getIntegerType(); 5449254721Semaste 5450254721Semaste enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits); 5451254721Semaste return true; 5452254721Semaste } 5453254721Semaste } 5454254721Semaste } 5455254721Semaste return false; 5456254721Semaste} 5457254721Semaste 5458254721Semaste 5459254721Semaste 5460254721Semaste 5461254721Semaste 5462254721Semaste 5463254721Semaste 5464254721Semastebool 5465254721SemasteClangASTType::AddEnumerationValueToEnumerationType (const ClangASTType &enumerator_clang_type, 5466254721Semaste const Declaration &decl, 5467254721Semaste const char *name, 5468254721Semaste int64_t enum_value, 5469254721Semaste uint32_t enum_value_bit_size) 5470254721Semaste{ 5471254721Semaste if (IsValid() && enumerator_clang_type.IsValid() && name && name[0]) 5472254721Semaste { 5473254721Semaste QualType enum_qual_type (GetCanonicalQualType()); 5474254721Semaste 5475254721Semaste bool is_signed = false; 5476254721Semaste enumerator_clang_type.IsIntegerType (is_signed); 5477254721Semaste const clang::Type *clang_type = enum_qual_type.getTypePtr(); 5478254721Semaste if (clang_type) 5479254721Semaste { 5480254721Semaste const EnumType *enum_type = dyn_cast<EnumType>(clang_type); 5481254721Semaste 5482254721Semaste if (enum_type) 5483254721Semaste { 5484254721Semaste llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed); 5485254721Semaste enum_llvm_apsint = enum_value; 5486254721Semaste EnumConstantDecl *enumerator_decl = 5487254721Semaste EnumConstantDecl::Create (*m_ast, 5488254721Semaste enum_type->getDecl(), 5489254721Semaste SourceLocation(), 5490254721Semaste name ? &m_ast->Idents.get(name) : NULL, // Identifier 5491254721Semaste enumerator_clang_type.GetQualType(), 5492254721Semaste NULL, 5493254721Semaste enum_llvm_apsint); 5494254721Semaste 5495254721Semaste if (enumerator_decl) 5496254721Semaste { 5497254721Semaste enum_type->getDecl()->addDecl(enumerator_decl); 5498254721Semaste 5499254721Semaste#ifdef LLDB_CONFIGURATION_DEBUG 5500254721Semaste VerifyDecl(enumerator_decl); 5501254721Semaste#endif 5502254721Semaste 5503254721Semaste return true; 5504254721Semaste } 5505254721Semaste } 5506254721Semaste } 5507254721Semaste } 5508254721Semaste return false; 5509254721Semaste} 5510254721Semaste 5511254721Semaste 5512254721SemasteClangASTType 5513254721SemasteClangASTType::GetEnumerationIntegerType () const 5514254721Semaste{ 5515254721Semaste QualType enum_qual_type (GetCanonicalQualType()); 5516254721Semaste const clang::Type *clang_type = enum_qual_type.getTypePtr(); 5517254721Semaste if (clang_type) 5518254721Semaste { 5519254721Semaste const EnumType *enum_type = dyn_cast<EnumType>(clang_type); 5520254721Semaste if (enum_type) 5521254721Semaste { 5522254721Semaste EnumDecl *enum_decl = enum_type->getDecl(); 5523254721Semaste if (enum_decl) 5524254721Semaste return ClangASTType (m_ast, enum_decl->getIntegerType()); 5525254721Semaste } 5526254721Semaste } 5527254721Semaste return ClangASTType(); 5528254721Semaste} 5529254721Semaste 5530254721SemasteClangASTType 5531254721SemasteClangASTType::CreateMemberPointerType (const ClangASTType &pointee_type) const 5532254721Semaste{ 5533254721Semaste if (IsValid() && pointee_type.IsValid()) 5534254721Semaste { 5535254721Semaste return ClangASTType (m_ast, m_ast->getMemberPointerType (pointee_type.GetQualType(), 5536254721Semaste GetQualType().getTypePtr())); 5537254721Semaste } 5538254721Semaste return ClangASTType(); 5539254721Semaste} 5540254721Semaste 5541254721Semaste 5542254721Semastesize_t 5543254721SemasteClangASTType::ConvertStringToFloatValue (const char *s, uint8_t *dst, size_t dst_size) const 5544254721Semaste{ 5545254721Semaste if (IsValid()) 5546254721Semaste { 5547254721Semaste QualType qual_type (GetCanonicalQualType()); 5548254721Semaste uint32_t count = 0; 5549254721Semaste bool is_complex = false; 5550254721Semaste if (IsFloatingPointType (count, is_complex)) 5551254721Semaste { 5552254721Semaste // TODO: handle complex and vector types 5553254721Semaste if (count != 1) 5554254721Semaste return false; 5555254721Semaste 5556254721Semaste StringRef s_sref(s); 5557254721Semaste APFloat ap_float(m_ast->getFloatTypeSemantics(qual_type), s_sref); 5558254721Semaste 5559254721Semaste const uint64_t bit_size = m_ast->getTypeSize (qual_type); 5560254721Semaste const uint64_t byte_size = bit_size / 8; 5561254721Semaste if (dst_size >= byte_size) 5562254721Semaste { 5563254721Semaste if (bit_size == sizeof(float)*8) 5564254721Semaste { 5565254721Semaste float float32 = ap_float.convertToFloat(); 5566254721Semaste ::memcpy (dst, &float32, byte_size); 5567254721Semaste return byte_size; 5568254721Semaste } 5569254721Semaste else if (bit_size >= 64) 5570254721Semaste { 5571254721Semaste llvm::APInt ap_int(ap_float.bitcastToAPInt()); 5572254721Semaste ::memcpy (dst, ap_int.getRawData(), byte_size); 5573254721Semaste return byte_size; 5574254721Semaste } 5575254721Semaste } 5576254721Semaste } 5577254721Semaste } 5578254721Semaste return 0; 5579254721Semaste} 5580254721Semaste 5581254721Semaste 5582254721Semaste 5583254721Semaste//---------------------------------------------------------------------- 5584254721Semaste// Dumping types 5585254721Semaste//---------------------------------------------------------------------- 5586254721Semaste#define DEPTH_INCREMENT 2 5587254721Semaste 5588254721Semastevoid 5589254721SemasteClangASTType::DumpValue (ExecutionContext *exe_ctx, 5590254721Semaste Stream *s, 5591254721Semaste lldb::Format format, 5592254721Semaste const lldb_private::DataExtractor &data, 5593254721Semaste lldb::offset_t data_byte_offset, 5594254721Semaste size_t data_byte_size, 5595254721Semaste uint32_t bitfield_bit_size, 5596254721Semaste uint32_t bitfield_bit_offset, 5597254721Semaste bool show_types, 5598254721Semaste bool show_summary, 5599254721Semaste bool verbose, 5600254721Semaste uint32_t depth) 5601254721Semaste{ 5602254721Semaste if (!IsValid()) 5603254721Semaste return; 5604254721Semaste 5605254721Semaste QualType qual_type(GetQualType()); 5606254721Semaste switch (qual_type->getTypeClass()) 5607254721Semaste { 5608254721Semaste case clang::Type::Record: 5609254721Semaste if (GetCompleteType ()) 5610254721Semaste { 5611254721Semaste const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 5612254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 5613254721Semaste assert(record_decl); 5614254721Semaste uint32_t field_bit_offset = 0; 5615254721Semaste uint32_t field_byte_offset = 0; 5616254721Semaste const ASTRecordLayout &record_layout = m_ast->getASTRecordLayout(record_decl); 5617254721Semaste uint32_t child_idx = 0; 5618254721Semaste 5619254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 5620254721Semaste if (cxx_record_decl) 5621254721Semaste { 5622254721Semaste // We might have base classes to print out first 5623254721Semaste CXXRecordDecl::base_class_const_iterator base_class, base_class_end; 5624254721Semaste for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); 5625254721Semaste base_class != base_class_end; 5626254721Semaste ++base_class) 5627254721Semaste { 5628254721Semaste const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); 5629254721Semaste 5630254721Semaste // Skip empty base classes 5631254721Semaste if (verbose == false && ClangASTContext::RecordHasFields(base_class_decl) == false) 5632254721Semaste continue; 5633254721Semaste 5634254721Semaste if (base_class->isVirtual()) 5635254721Semaste field_bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8; 5636254721Semaste else 5637254721Semaste field_bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8; 5638254721Semaste field_byte_offset = field_bit_offset / 8; 5639254721Semaste assert (field_bit_offset % 8 == 0); 5640254721Semaste if (child_idx == 0) 5641254721Semaste s->PutChar('{'); 5642254721Semaste else 5643254721Semaste s->PutChar(','); 5644254721Semaste 5645254721Semaste QualType base_class_qual_type = base_class->getType(); 5646254721Semaste std::string base_class_type_name(base_class_qual_type.getAsString()); 5647254721Semaste 5648254721Semaste // Indent and print the base class type name 5649254721Semaste s->Printf("\n%*s%s ", depth + DEPTH_INCREMENT, "", base_class_type_name.c_str()); 5650254721Semaste 5651254721Semaste std::pair<uint64_t, unsigned> base_class_type_info = m_ast->getTypeInfo(base_class_qual_type); 5652254721Semaste 5653254721Semaste // Dump the value of the member 5654254721Semaste ClangASTType base_clang_type(m_ast, base_class_qual_type); 5655254721Semaste base_clang_type.DumpValue (exe_ctx, 5656254721Semaste s, // Stream to dump to 5657254721Semaste base_clang_type.GetFormat(), // The format with which to display the member 5658254721Semaste data, // Data buffer containing all bytes for this type 5659254721Semaste data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from 5660254721Semaste base_class_type_info.first / 8, // Size of this type in bytes 5661254721Semaste 0, // Bitfield bit size 5662254721Semaste 0, // Bitfield bit offset 5663254721Semaste show_types, // Boolean indicating if we should show the variable types 5664254721Semaste show_summary, // Boolean indicating if we should show a summary for the current type 5665254721Semaste verbose, // Verbose output? 5666254721Semaste depth + DEPTH_INCREMENT); // Scope depth for any types that have children 5667254721Semaste 5668254721Semaste ++child_idx; 5669254721Semaste } 5670254721Semaste } 5671254721Semaste uint32_t field_idx = 0; 5672254721Semaste RecordDecl::field_iterator field, field_end; 5673254721Semaste for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx) 5674254721Semaste { 5675254721Semaste // Print the starting squiggly bracket (if this is the 5676254721Semaste // first member) or comman (for member 2 and beyong) for 5677254721Semaste // the struct/union/class member. 5678254721Semaste if (child_idx == 0) 5679254721Semaste s->PutChar('{'); 5680254721Semaste else 5681254721Semaste s->PutChar(','); 5682254721Semaste 5683254721Semaste // Indent 5684254721Semaste s->Printf("\n%*s", depth + DEPTH_INCREMENT, ""); 5685254721Semaste 5686254721Semaste QualType field_type = field->getType(); 5687254721Semaste // Print the member type if requested 5688254721Semaste // Figure out the type byte size (field_type_info.first) and 5689254721Semaste // alignment (field_type_info.second) from the AST context. 5690254721Semaste std::pair<uint64_t, unsigned> field_type_info = m_ast->getTypeInfo(field_type); 5691254721Semaste assert(field_idx < record_layout.getFieldCount()); 5692254721Semaste // Figure out the field offset within the current struct/union/class type 5693254721Semaste field_bit_offset = record_layout.getFieldOffset (field_idx); 5694254721Semaste field_byte_offset = field_bit_offset / 8; 5695254721Semaste uint32_t field_bitfield_bit_size = 0; 5696254721Semaste uint32_t field_bitfield_bit_offset = 0; 5697254721Semaste if (ClangASTContext::FieldIsBitfield (m_ast, *field, field_bitfield_bit_size)) 5698254721Semaste field_bitfield_bit_offset = field_bit_offset % 8; 5699254721Semaste 5700254721Semaste if (show_types) 5701254721Semaste { 5702254721Semaste std::string field_type_name(field_type.getAsString()); 5703254721Semaste if (field_bitfield_bit_size > 0) 5704254721Semaste s->Printf("(%s:%u) ", field_type_name.c_str(), field_bitfield_bit_size); 5705254721Semaste else 5706254721Semaste s->Printf("(%s) ", field_type_name.c_str()); 5707254721Semaste } 5708254721Semaste // Print the member name and equal sign 5709254721Semaste s->Printf("%s = ", field->getNameAsString().c_str()); 5710254721Semaste 5711254721Semaste 5712254721Semaste // Dump the value of the member 5713254721Semaste ClangASTType field_clang_type (m_ast, field_type); 5714254721Semaste field_clang_type.DumpValue (exe_ctx, 5715254721Semaste s, // Stream to dump to 5716254721Semaste field_clang_type.GetFormat(), // The format with which to display the member 5717254721Semaste data, // Data buffer containing all bytes for this type 5718254721Semaste data_byte_offset + field_byte_offset,// Offset into "data" where to grab value from 5719254721Semaste field_type_info.first / 8, // Size of this type in bytes 5720254721Semaste field_bitfield_bit_size, // Bitfield bit size 5721254721Semaste field_bitfield_bit_offset, // Bitfield bit offset 5722254721Semaste show_types, // Boolean indicating if we should show the variable types 5723254721Semaste show_summary, // Boolean indicating if we should show a summary for the current type 5724254721Semaste verbose, // Verbose output? 5725254721Semaste depth + DEPTH_INCREMENT); // Scope depth for any types that have children 5726254721Semaste } 5727254721Semaste 5728254721Semaste // Indent the trailing squiggly bracket 5729254721Semaste if (child_idx > 0) 5730254721Semaste s->Printf("\n%*s}", depth, ""); 5731254721Semaste } 5732254721Semaste return; 5733254721Semaste 5734254721Semaste case clang::Type::Enum: 5735254721Semaste if (GetCompleteType ()) 5736254721Semaste { 5737254721Semaste const EnumType *enum_type = cast<EnumType>(qual_type.getTypePtr()); 5738254721Semaste const EnumDecl *enum_decl = enum_type->getDecl(); 5739254721Semaste assert(enum_decl); 5740254721Semaste EnumDecl::enumerator_iterator enum_pos, enum_end_pos; 5741254721Semaste lldb::offset_t offset = data_byte_offset; 5742254721Semaste const int64_t enum_value = data.GetMaxU64Bitfield(&offset, data_byte_size, bitfield_bit_size, bitfield_bit_offset); 5743254721Semaste for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) 5744254721Semaste { 5745254721Semaste if (enum_pos->getInitVal() == enum_value) 5746254721Semaste { 5747254721Semaste s->Printf("%s", enum_pos->getNameAsString().c_str()); 5748254721Semaste return; 5749254721Semaste } 5750254721Semaste } 5751254721Semaste // If we have gotten here we didn't get find the enumerator in the 5752254721Semaste // enum decl, so just print the integer. 5753254721Semaste s->Printf("%" PRIi64, enum_value); 5754254721Semaste } 5755254721Semaste return; 5756254721Semaste 5757254721Semaste case clang::Type::ConstantArray: 5758254721Semaste { 5759254721Semaste const ConstantArrayType *array = cast<ConstantArrayType>(qual_type.getTypePtr()); 5760254721Semaste bool is_array_of_characters = false; 5761254721Semaste QualType element_qual_type = array->getElementType(); 5762254721Semaste 5763254721Semaste const clang::Type *canonical_type = element_qual_type->getCanonicalTypeInternal().getTypePtr(); 5764254721Semaste if (canonical_type) 5765254721Semaste is_array_of_characters = canonical_type->isCharType(); 5766254721Semaste 5767254721Semaste const uint64_t element_count = array->getSize().getLimitedValue(); 5768254721Semaste 5769254721Semaste std::pair<uint64_t, unsigned> field_type_info = m_ast->getTypeInfo(element_qual_type); 5770254721Semaste 5771254721Semaste uint32_t element_idx = 0; 5772254721Semaste uint32_t element_offset = 0; 5773254721Semaste uint64_t element_byte_size = field_type_info.first / 8; 5774254721Semaste uint32_t element_stride = element_byte_size; 5775254721Semaste 5776254721Semaste if (is_array_of_characters) 5777254721Semaste { 5778254721Semaste s->PutChar('"'); 5779254721Semaste data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size, element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); 5780254721Semaste s->PutChar('"'); 5781254721Semaste return; 5782254721Semaste } 5783254721Semaste else 5784254721Semaste { 5785254721Semaste ClangASTType element_clang_type(m_ast, element_qual_type); 5786254721Semaste lldb::Format element_format = element_clang_type.GetFormat(); 5787254721Semaste 5788254721Semaste for (element_idx = 0; element_idx < element_count; ++element_idx) 5789254721Semaste { 5790254721Semaste // Print the starting squiggly bracket (if this is the 5791254721Semaste // first member) or comman (for member 2 and beyong) for 5792254721Semaste // the struct/union/class member. 5793254721Semaste if (element_idx == 0) 5794254721Semaste s->PutChar('{'); 5795254721Semaste else 5796254721Semaste s->PutChar(','); 5797254721Semaste 5798254721Semaste // Indent and print the index 5799254721Semaste s->Printf("\n%*s[%u] ", depth + DEPTH_INCREMENT, "", element_idx); 5800254721Semaste 5801254721Semaste // Figure out the field offset within the current struct/union/class type 5802254721Semaste element_offset = element_idx * element_stride; 5803254721Semaste 5804254721Semaste // Dump the value of the member 5805254721Semaste element_clang_type.DumpValue (exe_ctx, 5806254721Semaste s, // Stream to dump to 5807254721Semaste element_format, // The format with which to display the element 5808254721Semaste data, // Data buffer containing all bytes for this type 5809254721Semaste data_byte_offset + element_offset,// Offset into "data" where to grab value from 5810254721Semaste element_byte_size, // Size of this type in bytes 5811254721Semaste 0, // Bitfield bit size 5812254721Semaste 0, // Bitfield bit offset 5813254721Semaste show_types, // Boolean indicating if we should show the variable types 5814254721Semaste show_summary, // Boolean indicating if we should show a summary for the current type 5815254721Semaste verbose, // Verbose output? 5816254721Semaste depth + DEPTH_INCREMENT); // Scope depth for any types that have children 5817254721Semaste } 5818254721Semaste 5819254721Semaste // Indent the trailing squiggly bracket 5820254721Semaste if (element_idx > 0) 5821254721Semaste s->Printf("\n%*s}", depth, ""); 5822254721Semaste } 5823254721Semaste } 5824254721Semaste return; 5825254721Semaste 5826254721Semaste case clang::Type::Typedef: 5827254721Semaste { 5828254721Semaste QualType typedef_qual_type = cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(); 5829254721Semaste 5830254721Semaste ClangASTType typedef_clang_type (m_ast, typedef_qual_type); 5831254721Semaste lldb::Format typedef_format = typedef_clang_type.GetFormat(); 5832254721Semaste std::pair<uint64_t, unsigned> typedef_type_info = m_ast->getTypeInfo(typedef_qual_type); 5833254721Semaste uint64_t typedef_byte_size = typedef_type_info.first / 8; 5834254721Semaste 5835254721Semaste return typedef_clang_type.DumpValue (exe_ctx, 5836254721Semaste s, // Stream to dump to 5837254721Semaste typedef_format, // The format with which to display the element 5838254721Semaste data, // Data buffer containing all bytes for this type 5839254721Semaste data_byte_offset, // Offset into "data" where to grab value from 5840254721Semaste typedef_byte_size, // Size of this type in bytes 5841254721Semaste bitfield_bit_size, // Bitfield bit size 5842254721Semaste bitfield_bit_offset,// Bitfield bit offset 5843254721Semaste show_types, // Boolean indicating if we should show the variable types 5844254721Semaste show_summary, // Boolean indicating if we should show a summary for the current type 5845254721Semaste verbose, // Verbose output? 5846254721Semaste depth); // Scope depth for any types that have children 5847254721Semaste } 5848254721Semaste break; 5849254721Semaste 5850254721Semaste case clang::Type::Elaborated: 5851254721Semaste { 5852254721Semaste QualType elaborated_qual_type = cast<ElaboratedType>(qual_type)->getNamedType(); 5853254721Semaste ClangASTType elaborated_clang_type (m_ast, elaborated_qual_type); 5854254721Semaste lldb::Format elaborated_format = elaborated_clang_type.GetFormat(); 5855254721Semaste std::pair<uint64_t, unsigned> elaborated_type_info = m_ast->getTypeInfo(elaborated_qual_type); 5856254721Semaste uint64_t elaborated_byte_size = elaborated_type_info.first / 8; 5857254721Semaste 5858254721Semaste return elaborated_clang_type.DumpValue (exe_ctx, 5859254721Semaste s, // Stream to dump to 5860254721Semaste elaborated_format, // The format with which to display the element 5861254721Semaste data, // Data buffer containing all bytes for this type 5862254721Semaste data_byte_offset, // Offset into "data" where to grab value from 5863254721Semaste elaborated_byte_size, // Size of this type in bytes 5864254721Semaste bitfield_bit_size, // Bitfield bit size 5865254721Semaste bitfield_bit_offset,// Bitfield bit offset 5866254721Semaste show_types, // Boolean indicating if we should show the variable types 5867254721Semaste show_summary, // Boolean indicating if we should show a summary for the current type 5868254721Semaste verbose, // Verbose output? 5869254721Semaste depth); // Scope depth for any types that have children 5870254721Semaste } 5871254721Semaste break; 5872254721Semaste 5873254721Semaste case clang::Type::Paren: 5874254721Semaste { 5875254721Semaste QualType desugar_qual_type = cast<ParenType>(qual_type)->desugar(); 5876254721Semaste ClangASTType desugar_clang_type (m_ast, desugar_qual_type); 5877254721Semaste 5878254721Semaste lldb::Format desugar_format = desugar_clang_type.GetFormat(); 5879254721Semaste std::pair<uint64_t, unsigned> desugar_type_info = m_ast->getTypeInfo(desugar_qual_type); 5880254721Semaste uint64_t desugar_byte_size = desugar_type_info.first / 8; 5881254721Semaste 5882254721Semaste return desugar_clang_type.DumpValue (exe_ctx, 5883254721Semaste s, // Stream to dump to 5884254721Semaste desugar_format, // The format with which to display the element 5885254721Semaste data, // Data buffer containing all bytes for this type 5886254721Semaste data_byte_offset, // Offset into "data" where to grab value from 5887254721Semaste desugar_byte_size, // Size of this type in bytes 5888254721Semaste bitfield_bit_size, // Bitfield bit size 5889254721Semaste bitfield_bit_offset,// Bitfield bit offset 5890254721Semaste show_types, // Boolean indicating if we should show the variable types 5891254721Semaste show_summary, // Boolean indicating if we should show a summary for the current type 5892254721Semaste verbose, // Verbose output? 5893254721Semaste depth); // Scope depth for any types that have children 5894254721Semaste } 5895254721Semaste break; 5896254721Semaste 5897254721Semaste default: 5898254721Semaste // We are down the a scalar type that we just need to display. 5899254721Semaste data.Dump(s, 5900254721Semaste data_byte_offset, 5901254721Semaste format, 5902254721Semaste data_byte_size, 5903254721Semaste 1, 5904254721Semaste UINT32_MAX, 5905254721Semaste LLDB_INVALID_ADDRESS, 5906254721Semaste bitfield_bit_size, 5907254721Semaste bitfield_bit_offset); 5908254721Semaste 5909254721Semaste if (show_summary) 5910254721Semaste DumpSummary (exe_ctx, s, data, data_byte_offset, data_byte_size); 5911254721Semaste break; 5912254721Semaste } 5913254721Semaste} 5914254721Semaste 5915254721Semaste 5916254721Semaste 5917254721Semaste 5918254721Semastebool 5919254721SemasteClangASTType::DumpTypeValue (Stream *s, 5920254721Semaste lldb::Format format, 5921254721Semaste const lldb_private::DataExtractor &data, 5922254721Semaste lldb::offset_t byte_offset, 5923254721Semaste size_t byte_size, 5924254721Semaste uint32_t bitfield_bit_size, 5925254721Semaste uint32_t bitfield_bit_offset, 5926254721Semaste ExecutionContextScope *exe_scope) 5927254721Semaste{ 5928254721Semaste if (!IsValid()) 5929254721Semaste return false; 5930254721Semaste if (IsAggregateType()) 5931254721Semaste { 5932254721Semaste return false; 5933254721Semaste } 5934254721Semaste else 5935254721Semaste { 5936254721Semaste QualType qual_type(GetQualType()); 5937254721Semaste 5938254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 5939254721Semaste switch (type_class) 5940254721Semaste { 5941254721Semaste case clang::Type::Typedef: 5942254721Semaste { 5943254721Semaste QualType typedef_qual_type = cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(); 5944254721Semaste ClangASTType typedef_clang_type (m_ast, typedef_qual_type); 5945254721Semaste if (format == eFormatDefault) 5946254721Semaste format = typedef_clang_type.GetFormat(); 5947254721Semaste std::pair<uint64_t, unsigned> typedef_type_info = m_ast->getTypeInfo(typedef_qual_type); 5948254721Semaste uint64_t typedef_byte_size = typedef_type_info.first / 8; 5949254721Semaste 5950254721Semaste return typedef_clang_type.DumpTypeValue (s, 5951254721Semaste format, // The format with which to display the element 5952254721Semaste data, // Data buffer containing all bytes for this type 5953254721Semaste byte_offset, // Offset into "data" where to grab value from 5954254721Semaste typedef_byte_size, // Size of this type in bytes 5955254721Semaste bitfield_bit_size, // Size in bits of a bitfield value, if zero don't treat as a bitfield 5956254721Semaste bitfield_bit_offset, // Offset in bits of a bitfield value if bitfield_bit_size != 0 5957254721Semaste exe_scope); 5958254721Semaste } 5959254721Semaste break; 5960254721Semaste 5961254721Semaste case clang::Type::Enum: 5962254721Semaste // If our format is enum or default, show the enumeration value as 5963254721Semaste // its enumeration string value, else just display it as requested. 5964254721Semaste if ((format == eFormatEnum || format == eFormatDefault) && GetCompleteType ()) 5965254721Semaste { 5966254721Semaste const EnumType *enum_type = cast<EnumType>(qual_type.getTypePtr()); 5967254721Semaste const EnumDecl *enum_decl = enum_type->getDecl(); 5968254721Semaste assert(enum_decl); 5969254721Semaste EnumDecl::enumerator_iterator enum_pos, enum_end_pos; 5970254721Semaste const bool is_signed = qual_type->isSignedIntegerOrEnumerationType(); 5971254721Semaste lldb::offset_t offset = byte_offset; 5972254721Semaste if (is_signed) 5973254721Semaste { 5974254721Semaste const int64_t enum_svalue = data.GetMaxS64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); 5975254721Semaste for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) 5976254721Semaste { 5977254721Semaste if (enum_pos->getInitVal().getSExtValue() == enum_svalue) 5978254721Semaste { 5979254721Semaste s->PutCString (enum_pos->getNameAsString().c_str()); 5980254721Semaste return true; 5981254721Semaste } 5982254721Semaste } 5983254721Semaste // If we have gotten here we didn't get find the enumerator in the 5984254721Semaste // enum decl, so just print the integer. 5985254721Semaste s->Printf("%" PRIi64, enum_svalue); 5986254721Semaste } 5987254721Semaste else 5988254721Semaste { 5989254721Semaste const uint64_t enum_uvalue = data.GetMaxU64Bitfield (&offset, byte_size, bitfield_bit_size, bitfield_bit_offset); 5990254721Semaste for (enum_pos = enum_decl->enumerator_begin(), enum_end_pos = enum_decl->enumerator_end(); enum_pos != enum_end_pos; ++enum_pos) 5991254721Semaste { 5992254721Semaste if (enum_pos->getInitVal().getZExtValue() == enum_uvalue) 5993254721Semaste { 5994254721Semaste s->PutCString (enum_pos->getNameAsString().c_str()); 5995254721Semaste return true; 5996254721Semaste } 5997254721Semaste } 5998254721Semaste // If we have gotten here we didn't get find the enumerator in the 5999254721Semaste // enum decl, so just print the integer. 6000254721Semaste s->Printf("%" PRIu64, enum_uvalue); 6001254721Semaste } 6002254721Semaste return true; 6003254721Semaste } 6004254721Semaste // format was not enum, just fall through and dump the value as requested.... 6005254721Semaste 6006254721Semaste default: 6007254721Semaste // We are down the a scalar type that we just need to display. 6008254721Semaste { 6009254721Semaste uint32_t item_count = 1; 6010254721Semaste // A few formats, we might need to modify our size and count for depending 6011254721Semaste // on how we are trying to display the value... 6012254721Semaste switch (format) 6013254721Semaste { 6014254721Semaste default: 6015254721Semaste case eFormatBoolean: 6016254721Semaste case eFormatBinary: 6017254721Semaste case eFormatComplex: 6018254721Semaste case eFormatCString: // NULL terminated C strings 6019254721Semaste case eFormatDecimal: 6020254721Semaste case eFormatEnum: 6021254721Semaste case eFormatHex: 6022254721Semaste case eFormatHexUppercase: 6023254721Semaste case eFormatFloat: 6024254721Semaste case eFormatOctal: 6025254721Semaste case eFormatOSType: 6026254721Semaste case eFormatUnsigned: 6027254721Semaste case eFormatPointer: 6028254721Semaste case eFormatVectorOfChar: 6029254721Semaste case eFormatVectorOfSInt8: 6030254721Semaste case eFormatVectorOfUInt8: 6031254721Semaste case eFormatVectorOfSInt16: 6032254721Semaste case eFormatVectorOfUInt16: 6033254721Semaste case eFormatVectorOfSInt32: 6034254721Semaste case eFormatVectorOfUInt32: 6035254721Semaste case eFormatVectorOfSInt64: 6036254721Semaste case eFormatVectorOfUInt64: 6037254721Semaste case eFormatVectorOfFloat32: 6038254721Semaste case eFormatVectorOfFloat64: 6039254721Semaste case eFormatVectorOfUInt128: 6040254721Semaste break; 6041254721Semaste 6042254721Semaste case eFormatChar: 6043254721Semaste case eFormatCharPrintable: 6044254721Semaste case eFormatCharArray: 6045254721Semaste case eFormatBytes: 6046254721Semaste case eFormatBytesWithASCII: 6047254721Semaste item_count = byte_size; 6048254721Semaste byte_size = 1; 6049254721Semaste break; 6050254721Semaste 6051254721Semaste case eFormatUnicode16: 6052254721Semaste item_count = byte_size / 2; 6053254721Semaste byte_size = 2; 6054254721Semaste break; 6055254721Semaste 6056254721Semaste case eFormatUnicode32: 6057254721Semaste item_count = byte_size / 4; 6058254721Semaste byte_size = 4; 6059254721Semaste break; 6060254721Semaste } 6061254721Semaste return data.Dump (s, 6062254721Semaste byte_offset, 6063254721Semaste format, 6064254721Semaste byte_size, 6065254721Semaste item_count, 6066254721Semaste UINT32_MAX, 6067254721Semaste LLDB_INVALID_ADDRESS, 6068254721Semaste bitfield_bit_size, 6069254721Semaste bitfield_bit_offset, 6070254721Semaste exe_scope); 6071254721Semaste } 6072254721Semaste break; 6073254721Semaste } 6074254721Semaste } 6075254721Semaste return 0; 6076254721Semaste} 6077254721Semaste 6078254721Semaste 6079254721Semaste 6080254721Semastevoid 6081254721SemasteClangASTType::DumpSummary (ExecutionContext *exe_ctx, 6082254721Semaste Stream *s, 6083254721Semaste const lldb_private::DataExtractor &data, 6084254721Semaste lldb::offset_t data_byte_offset, 6085254721Semaste size_t data_byte_size) 6086254721Semaste{ 6087254721Semaste uint32_t length = 0; 6088254721Semaste if (IsCStringType (length)) 6089254721Semaste { 6090254721Semaste if (exe_ctx) 6091254721Semaste { 6092254721Semaste Process *process = exe_ctx->GetProcessPtr(); 6093254721Semaste if (process) 6094254721Semaste { 6095254721Semaste lldb::offset_t offset = data_byte_offset; 6096254721Semaste lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size); 6097254721Semaste std::vector<uint8_t> buf; 6098254721Semaste if (length > 0) 6099254721Semaste buf.resize (length); 6100254721Semaste else 6101254721Semaste buf.resize (256); 6102254721Semaste 6103254721Semaste lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(), process->GetByteOrder(), 4); 6104254721Semaste buf.back() = '\0'; 6105254721Semaste size_t bytes_read; 6106254721Semaste size_t total_cstr_len = 0; 6107254721Semaste Error error; 6108254721Semaste while ((bytes_read = process->ReadMemory (pointer_addresss, &buf.front(), buf.size(), error)) > 0) 6109254721Semaste { 6110254721Semaste const size_t len = strlen((const char *)&buf.front()); 6111254721Semaste if (len == 0) 6112254721Semaste break; 6113254721Semaste if (total_cstr_len == 0) 6114254721Semaste s->PutCString (" \""); 6115254721Semaste cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0); 6116254721Semaste total_cstr_len += len; 6117254721Semaste if (len < buf.size()) 6118254721Semaste break; 6119254721Semaste pointer_addresss += total_cstr_len; 6120254721Semaste } 6121254721Semaste if (total_cstr_len > 0) 6122254721Semaste s->PutChar ('"'); 6123254721Semaste } 6124254721Semaste } 6125254721Semaste } 6126254721Semaste} 6127254721Semaste 6128254721Semastevoid 6129254721SemasteClangASTType::DumpTypeDescription () const 6130254721Semaste{ 6131254721Semaste StreamFile s (stdout, false); 6132254721Semaste DumpTypeDescription (&s); 6133254721Semaste ClangASTMetadata *metadata = ClangASTContext::GetMetadata (m_ast, m_type); 6134254721Semaste if (metadata) 6135254721Semaste { 6136254721Semaste metadata->Dump (&s); 6137254721Semaste } 6138254721Semaste} 6139254721Semaste 6140254721Semastevoid 6141254721SemasteClangASTType::DumpTypeDescription (Stream *s) const 6142254721Semaste{ 6143254721Semaste if (IsValid()) 6144254721Semaste { 6145254721Semaste QualType qual_type(GetQualType()); 6146254721Semaste 6147254721Semaste SmallVector<char, 1024> buf; 6148254721Semaste raw_svector_ostream llvm_ostrm (buf); 6149254721Semaste 6150254721Semaste const clang::Type::TypeClass type_class = qual_type->getTypeClass(); 6151254721Semaste switch (type_class) 6152254721Semaste { 6153254721Semaste case clang::Type::ObjCObject: 6154254721Semaste case clang::Type::ObjCInterface: 6155254721Semaste { 6156254721Semaste GetCompleteType (); 6157254721Semaste 6158254721Semaste const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr()); 6159254721Semaste assert (objc_class_type); 6160254721Semaste if (objc_class_type) 6161254721Semaste { 6162254721Semaste ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface(); 6163254721Semaste if (class_interface_decl) 6164254721Semaste { 6165254721Semaste PrintingPolicy policy = m_ast->getPrintingPolicy(); 6166254721Semaste class_interface_decl->print(llvm_ostrm, policy, s->GetIndentLevel()); 6167254721Semaste } 6168254721Semaste } 6169254721Semaste } 6170254721Semaste break; 6171254721Semaste 6172254721Semaste case clang::Type::Typedef: 6173254721Semaste { 6174254721Semaste const TypedefType *typedef_type = qual_type->getAs<TypedefType>(); 6175254721Semaste if (typedef_type) 6176254721Semaste { 6177254721Semaste const TypedefNameDecl *typedef_decl = typedef_type->getDecl(); 6178254721Semaste std::string clang_typedef_name (typedef_decl->getQualifiedNameAsString()); 6179254721Semaste if (!clang_typedef_name.empty()) 6180254721Semaste { 6181254721Semaste s->PutCString ("typedef "); 6182254721Semaste s->PutCString (clang_typedef_name.c_str()); 6183254721Semaste } 6184254721Semaste } 6185254721Semaste } 6186254721Semaste break; 6187254721Semaste 6188254721Semaste case clang::Type::Elaborated: 6189254721Semaste ClangASTType (m_ast, cast<ElaboratedType>(qual_type)->getNamedType()).DumpTypeDescription(s); 6190254721Semaste return; 6191254721Semaste 6192254721Semaste case clang::Type::Paren: 6193254721Semaste ClangASTType (m_ast, cast<ParenType>(qual_type)->desugar()).DumpTypeDescription(s); 6194254721Semaste return; 6195254721Semaste 6196254721Semaste case clang::Type::Record: 6197254721Semaste { 6198254721Semaste GetCompleteType (); 6199254721Semaste 6200254721Semaste const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr()); 6201254721Semaste const RecordDecl *record_decl = record_type->getDecl(); 6202254721Semaste const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); 6203254721Semaste 6204254721Semaste if (cxx_record_decl) 6205254721Semaste cxx_record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel()); 6206254721Semaste else 6207254721Semaste record_decl->print(llvm_ostrm, m_ast->getPrintingPolicy(), s->GetIndentLevel()); 6208254721Semaste } 6209254721Semaste break; 6210254721Semaste 6211254721Semaste default: 6212254721Semaste { 6213254721Semaste const TagType *tag_type = dyn_cast<TagType>(qual_type.getTypePtr()); 6214254721Semaste if (tag_type) 6215254721Semaste { 6216254721Semaste TagDecl *tag_decl = tag_type->getDecl(); 6217254721Semaste if (tag_decl) 6218254721Semaste tag_decl->print(llvm_ostrm, 0); 6219254721Semaste } 6220254721Semaste else 6221254721Semaste { 6222254721Semaste std::string clang_type_name(qual_type.getAsString()); 6223254721Semaste if (!clang_type_name.empty()) 6224254721Semaste s->PutCString (clang_type_name.c_str()); 6225254721Semaste } 6226254721Semaste } 6227254721Semaste } 6228254721Semaste 6229254721Semaste llvm_ostrm.flush(); 6230254721Semaste if (buf.size() > 0) 6231254721Semaste { 6232254721Semaste s->Write (buf.data(), buf.size()); 6233254721Semaste } 6234254721Semaste } 6235254721Semaste} 6236254721Semaste 6237254721Semastebool 6238254721SemasteClangASTType::GetValueAsScalar (const lldb_private::DataExtractor &data, 6239254721Semaste lldb::offset_t data_byte_offset, 6240254721Semaste size_t data_byte_size, 6241254721Semaste Scalar &value) const 6242254721Semaste{ 6243254721Semaste if (!IsValid()) 6244254721Semaste return false; 6245254721Semaste 6246254721Semaste if (IsAggregateType ()) 6247254721Semaste { 6248254721Semaste return false; // Aggregate types don't have scalar values 6249254721Semaste } 6250254721Semaste else 6251254721Semaste { 6252254721Semaste uint64_t count = 0; 6253254721Semaste lldb::Encoding encoding = GetEncoding (count); 6254254721Semaste 6255254721Semaste if (encoding == lldb::eEncodingInvalid || count != 1) 6256254721Semaste return false; 6257254721Semaste 6258254721Semaste const uint64_t byte_size = GetByteSize(); 6259254721Semaste lldb::offset_t offset = data_byte_offset; 6260254721Semaste switch (encoding) 6261254721Semaste { 6262254721Semaste case lldb::eEncodingInvalid: 6263254721Semaste break; 6264254721Semaste case lldb::eEncodingVector: 6265254721Semaste break; 6266254721Semaste case lldb::eEncodingUint: 6267254721Semaste if (byte_size <= sizeof(unsigned long long)) 6268254721Semaste { 6269254721Semaste uint64_t uval64 = data.GetMaxU64 (&offset, byte_size); 6270254721Semaste if (byte_size <= sizeof(unsigned int)) 6271254721Semaste { 6272254721Semaste value = (unsigned int)uval64; 6273254721Semaste return true; 6274254721Semaste } 6275254721Semaste else if (byte_size <= sizeof(unsigned long)) 6276254721Semaste { 6277254721Semaste value = (unsigned long)uval64; 6278254721Semaste return true; 6279254721Semaste } 6280254721Semaste else if (byte_size <= sizeof(unsigned long long)) 6281254721Semaste { 6282254721Semaste value = (unsigned long long )uval64; 6283254721Semaste return true; 6284254721Semaste } 6285254721Semaste else 6286254721Semaste value.Clear(); 6287254721Semaste } 6288254721Semaste break; 6289254721Semaste 6290254721Semaste case lldb::eEncodingSint: 6291254721Semaste if (byte_size <= sizeof(long long)) 6292254721Semaste { 6293254721Semaste int64_t sval64 = data.GetMaxS64 (&offset, byte_size); 6294254721Semaste if (byte_size <= sizeof(int)) 6295254721Semaste { 6296254721Semaste value = (int)sval64; 6297254721Semaste return true; 6298254721Semaste } 6299254721Semaste else if (byte_size <= sizeof(long)) 6300254721Semaste { 6301254721Semaste value = (long)sval64; 6302254721Semaste return true; 6303254721Semaste } 6304254721Semaste else if (byte_size <= sizeof(long long)) 6305254721Semaste { 6306254721Semaste value = (long long )sval64; 6307254721Semaste return true; 6308254721Semaste } 6309254721Semaste else 6310254721Semaste value.Clear(); 6311254721Semaste } 6312254721Semaste break; 6313254721Semaste 6314254721Semaste case lldb::eEncodingIEEE754: 6315254721Semaste if (byte_size <= sizeof(long double)) 6316254721Semaste { 6317254721Semaste uint32_t u32; 6318254721Semaste uint64_t u64; 6319254721Semaste if (byte_size == sizeof(float)) 6320254721Semaste { 6321254721Semaste if (sizeof(float) == sizeof(uint32_t)) 6322254721Semaste { 6323254721Semaste u32 = data.GetU32(&offset); 6324254721Semaste value = *((float *)&u32); 6325254721Semaste return true; 6326254721Semaste } 6327254721Semaste else if (sizeof(float) == sizeof(uint64_t)) 6328254721Semaste { 6329254721Semaste u64 = data.GetU64(&offset); 6330254721Semaste value = *((float *)&u64); 6331254721Semaste return true; 6332254721Semaste } 6333254721Semaste } 6334254721Semaste else 6335254721Semaste if (byte_size == sizeof(double)) 6336254721Semaste { 6337254721Semaste if (sizeof(double) == sizeof(uint32_t)) 6338254721Semaste { 6339254721Semaste u32 = data.GetU32(&offset); 6340254721Semaste value = *((double *)&u32); 6341254721Semaste return true; 6342254721Semaste } 6343254721Semaste else if (sizeof(double) == sizeof(uint64_t)) 6344254721Semaste { 6345254721Semaste u64 = data.GetU64(&offset); 6346254721Semaste value = *((double *)&u64); 6347254721Semaste return true; 6348254721Semaste } 6349254721Semaste } 6350254721Semaste else 6351254721Semaste if (byte_size == sizeof(long double)) 6352254721Semaste { 6353254721Semaste if (sizeof(long double) == sizeof(uint32_t)) 6354254721Semaste { 6355254721Semaste u32 = data.GetU32(&offset); 6356254721Semaste value = *((long double *)&u32); 6357254721Semaste return true; 6358254721Semaste } 6359254721Semaste else if (sizeof(long double) == sizeof(uint64_t)) 6360254721Semaste { 6361254721Semaste u64 = data.GetU64(&offset); 6362254721Semaste value = *((long double *)&u64); 6363254721Semaste return true; 6364254721Semaste } 6365254721Semaste } 6366254721Semaste } 6367254721Semaste break; 6368254721Semaste } 6369254721Semaste } 6370254721Semaste return false; 6371254721Semaste} 6372254721Semaste 6373254721Semastebool 6374254721SemasteClangASTType::SetValueFromScalar (const Scalar &value, Stream &strm) 6375254721Semaste{ 6376254721Semaste // Aggregate types don't have scalar values 6377254721Semaste if (!IsAggregateType ()) 6378254721Semaste { 6379254721Semaste strm.GetFlags().Set(Stream::eBinary); 6380254721Semaste uint64_t count = 0; 6381254721Semaste lldb::Encoding encoding = GetEncoding (count); 6382254721Semaste 6383254721Semaste if (encoding == lldb::eEncodingInvalid || count != 1) 6384254721Semaste return false; 6385254721Semaste 6386254721Semaste const uint64_t bit_width = GetBitSize(); 6387254721Semaste // This function doesn't currently handle non-byte aligned assignments 6388254721Semaste if ((bit_width % 8) != 0) 6389254721Semaste return false; 6390254721Semaste 6391254721Semaste const uint64_t byte_size = (bit_width + 7 ) / 8; 6392254721Semaste switch (encoding) 6393254721Semaste { 6394254721Semaste case lldb::eEncodingInvalid: 6395254721Semaste break; 6396254721Semaste case lldb::eEncodingVector: 6397254721Semaste break; 6398254721Semaste case lldb::eEncodingUint: 6399254721Semaste switch (byte_size) 6400254721Semaste { 6401254721Semaste case 1: strm.PutHex8(value.UInt()); return true; 6402254721Semaste case 2: strm.PutHex16(value.UInt()); return true; 6403254721Semaste case 4: strm.PutHex32(value.UInt()); return true; 6404254721Semaste case 8: strm.PutHex64(value.ULongLong()); return true; 6405254721Semaste default: 6406254721Semaste break; 6407254721Semaste } 6408254721Semaste break; 6409254721Semaste 6410254721Semaste case lldb::eEncodingSint: 6411254721Semaste switch (byte_size) 6412254721Semaste { 6413254721Semaste case 1: strm.PutHex8(value.SInt()); return true; 6414254721Semaste case 2: strm.PutHex16(value.SInt()); return true; 6415254721Semaste case 4: strm.PutHex32(value.SInt()); return true; 6416254721Semaste case 8: strm.PutHex64(value.SLongLong()); return true; 6417254721Semaste default: 6418254721Semaste break; 6419254721Semaste } 6420254721Semaste break; 6421254721Semaste 6422254721Semaste case lldb::eEncodingIEEE754: 6423254721Semaste if (byte_size <= sizeof(long double)) 6424254721Semaste { 6425254721Semaste if (byte_size == sizeof(float)) 6426254721Semaste { 6427254721Semaste strm.PutFloat(value.Float()); 6428254721Semaste return true; 6429254721Semaste } 6430254721Semaste else 6431254721Semaste if (byte_size == sizeof(double)) 6432254721Semaste { 6433254721Semaste strm.PutDouble(value.Double()); 6434254721Semaste return true; 6435254721Semaste } 6436254721Semaste else 6437254721Semaste if (byte_size == sizeof(long double)) 6438254721Semaste { 6439254721Semaste strm.PutDouble(value.LongDouble()); 6440254721Semaste return true; 6441254721Semaste } 6442254721Semaste } 6443254721Semaste break; 6444254721Semaste } 6445254721Semaste } 6446254721Semaste return false; 6447254721Semaste} 6448254721Semaste 6449254721Semastebool 6450254721SemasteClangASTType::ReadFromMemory (lldb_private::ExecutionContext *exe_ctx, 6451254721Semaste lldb::addr_t addr, 6452254721Semaste AddressType address_type, 6453254721Semaste lldb_private::DataExtractor &data) 6454254721Semaste{ 6455254721Semaste if (!IsValid()) 6456254721Semaste return false; 6457254721Semaste 6458254721Semaste // Can't convert a file address to anything valid without more 6459254721Semaste // context (which Module it came from) 6460254721Semaste if (address_type == eAddressTypeFile) 6461254721Semaste return false; 6462254721Semaste 6463254721Semaste if (!GetCompleteType()) 6464254721Semaste return false; 6465254721Semaste 6466254721Semaste const uint64_t byte_size = GetByteSize(); 6467254721Semaste if (data.GetByteSize() < byte_size) 6468254721Semaste { 6469254721Semaste lldb::DataBufferSP data_sp(new DataBufferHeap (byte_size, '\0')); 6470254721Semaste data.SetData(data_sp); 6471254721Semaste } 6472254721Semaste 6473254721Semaste uint8_t* dst = (uint8_t*)data.PeekData(0, byte_size); 6474254721Semaste if (dst != NULL) 6475254721Semaste { 6476254721Semaste if (address_type == eAddressTypeHost) 6477254721Semaste { 6478254721Semaste if (addr == 0) 6479254721Semaste return false; 6480254721Semaste // The address is an address in this process, so just copy it 6481254721Semaste memcpy (dst, (uint8_t*)NULL + addr, byte_size); 6482254721Semaste return true; 6483254721Semaste } 6484254721Semaste else 6485254721Semaste { 6486254721Semaste Process *process = NULL; 6487254721Semaste if (exe_ctx) 6488254721Semaste process = exe_ctx->GetProcessPtr(); 6489254721Semaste if (process) 6490254721Semaste { 6491254721Semaste Error error; 6492254721Semaste return process->ReadMemory(addr, dst, byte_size, error) == byte_size; 6493254721Semaste } 6494254721Semaste } 6495254721Semaste } 6496254721Semaste return false; 6497254721Semaste} 6498254721Semaste 6499254721Semastebool 6500254721SemasteClangASTType::WriteToMemory (lldb_private::ExecutionContext *exe_ctx, 6501254721Semaste lldb::addr_t addr, 6502254721Semaste AddressType address_type, 6503254721Semaste StreamString &new_value) 6504254721Semaste{ 6505254721Semaste if (!IsValid()) 6506254721Semaste return false; 6507254721Semaste 6508254721Semaste // Can't convert a file address to anything valid without more 6509254721Semaste // context (which Module it came from) 6510254721Semaste if (address_type == eAddressTypeFile) 6511254721Semaste return false; 6512254721Semaste 6513254721Semaste if (!GetCompleteType()) 6514254721Semaste return false; 6515254721Semaste 6516254721Semaste const uint64_t byte_size = GetByteSize(); 6517254721Semaste 6518254721Semaste if (byte_size > 0) 6519254721Semaste { 6520254721Semaste if (address_type == eAddressTypeHost) 6521254721Semaste { 6522254721Semaste // The address is an address in this process, so just copy it 6523254721Semaste memcpy ((void *)addr, new_value.GetData(), byte_size); 6524254721Semaste return true; 6525254721Semaste } 6526254721Semaste else 6527254721Semaste { 6528254721Semaste Process *process = NULL; 6529254721Semaste if (exe_ctx) 6530254721Semaste process = exe_ctx->GetProcessPtr(); 6531254721Semaste if (process) 6532254721Semaste { 6533254721Semaste Error error; 6534254721Semaste return process->WriteMemory(addr, new_value.GetData(), byte_size, error) == byte_size; 6535254721Semaste } 6536254721Semaste } 6537254721Semaste } 6538254721Semaste return false; 6539254721Semaste} 6540254721Semaste 6541254721Semaste 6542254721Semaste//CXXRecordDecl * 6543254721Semaste//ClangASTType::GetAsCXXRecordDecl (lldb::clang_type_t opaque_clang_qual_type) 6544254721Semaste//{ 6545254721Semaste// if (opaque_clang_qual_type) 6546254721Semaste// return QualType::getFromOpaquePtr(opaque_clang_qual_type)->getAsCXXRecordDecl(); 6547254721Semaste// return NULL; 6548254721Semaste//} 6549254721Semaste 6550254721Semastebool 6551254721Semastelldb_private::operator == (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs) 6552254721Semaste{ 6553254721Semaste return lhs.GetASTContext() == rhs.GetASTContext() && lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType(); 6554254721Semaste} 6555254721Semaste 6556254721Semaste 6557254721Semastebool 6558254721Semastelldb_private::operator != (const lldb_private::ClangASTType &lhs, const lldb_private::ClangASTType &rhs) 6559254721Semaste{ 6560254721Semaste return lhs.GetASTContext() != rhs.GetASTContext() || lhs.GetOpaqueQualType() != rhs.GetOpaqueQualType(); 6561254721Semaste} 6562254721Semaste 6563254721Semaste 6564